Fixed: 1774625 - duplicate one function block down into a folded php-doc
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / lookup / ClassScope.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.Clinit;
16 import net.sourceforge.phpdt.internal.compiler.ast.FieldDeclaration;
17 import net.sourceforge.phpdt.internal.compiler.ast.TypeDeclaration;
18 import net.sourceforge.phpdt.internal.compiler.ast.TypeReference;
19 import net.sourceforge.phpdt.internal.compiler.impl.ReferenceContext;
20 import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
21 import net.sourceforge.phpdt.internal.compiler.util.HashtableOfObject;
22
23 public class ClassScope extends Scope {
24         public TypeDeclaration referenceContext;
25
26         public ClassScope(Scope parent, TypeDeclaration context) {
27                 super(CLASS_SCOPE, parent);
28                 this.referenceContext = context;
29         }
30
31         void buildAnonymousTypeBinding(SourceTypeBinding enclosingType,
32                         ReferenceBinding supertype) {
33
34                 LocalTypeBinding anonymousType = buildLocalType(enclosingType,
35                                 enclosingType.fPackage);
36
37                 SourceTypeBinding sourceType = referenceContext.binding;
38                 if (supertype.isInterface()) {
39                         sourceType.superclass = getJavaLangObject();
40                         sourceType.superInterfaces = new ReferenceBinding[] { supertype };
41                 } else {
42                         sourceType.superclass = supertype;
43                         sourceType.superInterfaces = TypeBinding.NoSuperInterfaces;
44                 }
45                 connectMemberTypes();
46                 buildFieldsAndMethods();
47                 anonymousType.faultInTypesForFieldsAndMethods();
48                 sourceType.verifyMethods(environment().methodVerifier());
49         }
50
51         private void buildFields() {
52                 if (referenceContext.fields == null) {
53                         referenceContext.binding.fields = NoFields;
54                         return;
55                 }
56                 // count the number of fields vs. initializers
57                 FieldDeclaration[] fields = referenceContext.fields;
58                 int size = fields.length;
59                 int count = 0;
60                 for (int i = 0; i < size; i++)
61                         if (fields[i].isField())
62                                 count++;
63
64                 // iterate the field declarations to create the bindings, lose all
65                 // duplicates
66                 FieldBinding[] fieldBindings = new FieldBinding[count];
67                 HashtableOfObject knownFieldNames = new HashtableOfObject(count);
68                 boolean duplicate = false;
69                 count = 0;
70                 for (int i = 0; i < size; i++) {
71                         FieldDeclaration field = fields[i];
72                         if (!field.isField()) {
73                                 if (referenceContext.binding.isInterface())
74                                         problemReporter().interfaceCannotHaveInitializers(
75                                                         referenceContext.binding, field);
76                         } else {
77                                 FieldBinding fieldBinding = new FieldBinding(field, null,
78                                                 referenceContext.binding);
79                                 // field's type will be resolved when needed for top level types
80                                 checkAndSetModifiersForField(fieldBinding, field);
81
82                                 if (knownFieldNames.containsKey(field.name)) {
83                                         duplicate = true;
84                                         FieldBinding previousBinding = (FieldBinding) knownFieldNames
85                                                         .get(field.name);
86                                         if (previousBinding != null) {
87                                                 for (int f = 0; f < i; f++) {
88                                                         FieldDeclaration previousField = fields[f];
89                                                         if (previousField.binding == previousBinding) {
90                                                                 problemReporter()
91                                                                                 .duplicateFieldInType(
92                                                                                                 referenceContext.binding,
93                                                                                                 previousField);
94                                                                 previousField.binding = null;
95                                                                 break;
96                                                         }
97                                                 }
98                                         }
99                                         knownFieldNames.put(field.name, null); // ensure that the
100                                                                                                                         // duplicate field
101                                                                                                                         // is found &
102                                                                                                                         // removed
103                                         problemReporter().duplicateFieldInType(
104                                                         referenceContext.binding, field);
105                                         field.binding = null;
106                                 } else {
107                                         knownFieldNames.put(field.name, fieldBinding);
108                                         // remember that we have seen a field with this name
109                                         if (fieldBinding != null)
110                                                 fieldBindings[count++] = fieldBinding;
111                                 }
112                         }
113                 }
114                 // remove duplicate fields
115                 if (duplicate) {
116                         FieldBinding[] newFieldBindings = new FieldBinding[knownFieldNames
117                                         .size() - 1];
118                         // we know we'll be removing at least 1 duplicate name
119                         size = count;
120                         count = 0;
121                         for (int i = 0; i < size; i++) {
122                                 FieldBinding fieldBinding = fieldBindings[i];
123                                 if (knownFieldNames.get(fieldBinding.name) != null)
124                                         newFieldBindings[count++] = fieldBinding;
125                         }
126                         fieldBindings = newFieldBindings;
127                 }
128
129                 if (count != fieldBindings.length)
130                         System.arraycopy(fieldBindings, 0,
131                                         fieldBindings = new FieldBinding[count], 0, count);
132                 for (int i = 0; i < count; i++)
133                         fieldBindings[i].id = i;
134                 referenceContext.binding.fields = fieldBindings;
135         }
136
137         void buildFieldsAndMethods() {
138                 buildFields();
139                 buildMethods();
140
141                 SourceTypeBinding sourceType = referenceContext.binding;
142                 if (sourceType.isMemberType() && !sourceType.isLocalType())
143                         ((MemberTypeBinding) sourceType).checkSyntheticArgsAndFields();
144
145                 ReferenceBinding[] memberTypes = sourceType.memberTypes;
146                 for (int i = 0, length = memberTypes.length; i < length; i++)
147                         ((SourceTypeBinding) memberTypes[i]).scope.buildFieldsAndMethods();
148         }
149
150         private LocalTypeBinding buildLocalType(SourceTypeBinding enclosingType,
151                         PackageBinding packageBinding) {
152                 referenceContext.scope = this;
153                 referenceContext.staticInitializerScope = new MethodScope(this,
154                                 referenceContext, true);
155                 referenceContext.initializerScope = new MethodScope(this,
156                                 referenceContext, false);
157
158                 // build the binding or the local type
159                 LocalTypeBinding localType = new LocalTypeBinding(this, enclosingType);
160                 referenceContext.binding = localType;
161                 checkAndSetModifiers();
162
163                 // Look at member types
164                 ReferenceBinding[] memberTypeBindings = NoMemberTypes;
165                 if (referenceContext.memberTypes != null) {
166                         int size = referenceContext.memberTypes.length;
167                         memberTypeBindings = new ReferenceBinding[size];
168                         int count = 0;
169                         nextMember: for (int i = 0; i < size; i++) {
170                                 TypeDeclaration memberContext = referenceContext.memberTypes[i];
171                                 if (memberContext.isInterface()) {
172                                         problemReporter().nestedClassCannotDeclareInterface(
173                                                         memberContext);
174                                         continue nextMember;
175                                 }
176                                 ReferenceBinding type = localType;
177                                 // check that the member does not conflict with an enclosing
178                                 // type
179                                 do {
180                                         if (CharOperation.equals(type.sourceName,
181                                                         memberContext.name)) {
182                                                 problemReporter().hidingEnclosingType(memberContext);
183                                                 continue nextMember;
184                                         }
185                                         type = type.enclosingType();
186                                 } while (type != null);
187                                 // check the member type does not conflict with another sibling
188                                 // member type
189                                 for (int j = 0; j < i; j++) {
190                                         if (CharOperation.equals(
191                                                         referenceContext.memberTypes[j].name,
192                                                         memberContext.name)) {
193                                                 problemReporter().duplicateNestedType(memberContext);
194                                                 continue nextMember;
195                                         }
196                                 }
197
198                                 ClassScope memberScope = new ClassScope(this,
199                                                 referenceContext.memberTypes[i]);
200                                 LocalTypeBinding memberBinding = memberScope.buildLocalType(
201                                                 localType, packageBinding);
202                                 memberBinding.setAsMemberType();
203                                 memberTypeBindings[count++] = memberBinding;
204                         }
205                         if (count != size)
206                                 System.arraycopy(memberTypeBindings, 0,
207                                                 memberTypeBindings = new ReferenceBinding[count], 0,
208                                                 count);
209                 }
210                 localType.memberTypes = memberTypeBindings;
211                 return localType;
212         }
213
214         void buildLocalTypeBinding(SourceTypeBinding enclosingType) {
215
216                 LocalTypeBinding localType = buildLocalType(enclosingType,
217                                 enclosingType.fPackage);
218                 connectTypeHierarchy();
219                 buildFieldsAndMethods();
220                 localType.faultInTypesForFieldsAndMethods();
221
222                 referenceContext.binding.verifyMethods(environment().methodVerifier());
223         }
224
225         private void buildMethods() {
226                 if (referenceContext.methods == null) {
227                         referenceContext.binding.methods = NoMethods;
228                         return;
229                 }
230
231                 // iterate the method declarations to create the bindings
232                 AbstractMethodDeclaration[] methods = referenceContext.methods;
233                 int size = methods.length;
234                 int clinitIndex = -1;
235                 for (int i = 0; i < size; i++) {
236                         if (methods[i] instanceof Clinit) {
237                                 clinitIndex = i;
238                                 break;
239                         }
240                 }
241                 MethodBinding[] methodBindings = new MethodBinding[clinitIndex == -1 ? size
242                                 : size - 1];
243
244                 int count = 0;
245                 for (int i = 0; i < size; i++) {
246                         if (i != clinitIndex) {
247                                 MethodScope scope = new MethodScope(this, methods[i], false);
248                                 MethodBinding methodBinding = scope.createMethod(methods[i]);
249                                 if (methodBinding != null) // is null if binding could not be
250                                                                                         // created
251                                         methodBindings[count++] = methodBinding;
252                         }
253                 }
254                 if (count != methodBindings.length)
255                         System.arraycopy(methodBindings, 0,
256                                         methodBindings = new MethodBinding[count], 0, count);
257
258                 referenceContext.binding.methods = methodBindings;
259                 referenceContext.binding.modifiers |= AccUnresolved; // until
260                                                                                                                                 // methods() is
261                                                                                                                                 // sent
262         }
263
264         SourceTypeBinding buildType(SourceTypeBinding enclosingType,
265                         PackageBinding packageBinding) {
266                 // provide the typeDeclaration with needed scopes
267                 referenceContext.scope = this;
268                 referenceContext.staticInitializerScope = new MethodScope(this,
269                                 referenceContext, true);
270                 referenceContext.initializerScope = new MethodScope(this,
271                                 referenceContext, false);
272
273                 if (enclosingType == null) {
274                         char[][] className = CharOperation.arrayConcat(
275                                         packageBinding.compoundName, referenceContext.name);
276                         referenceContext.binding = new SourceTypeBinding(className,
277                                         packageBinding, this);
278                 } else {
279                         char[][] className = CharOperation
280                                         .deepCopy(enclosingType.compoundName);
281                         className[className.length - 1] = CharOperation
282                                         .concat(className[className.length - 1],
283                                                         referenceContext.name, '$');
284                         referenceContext.binding = new MemberTypeBinding(className, this,
285                                         enclosingType);
286                 }
287
288                 SourceTypeBinding sourceType = referenceContext.binding;
289                 sourceType.fPackage.addType(sourceType);
290                 checkAndSetModifiers();
291
292                 // Look at member types
293                 ReferenceBinding[] memberTypeBindings = NoMemberTypes;
294                 if (referenceContext.memberTypes != null) {
295                         int size = referenceContext.memberTypes.length;
296                         memberTypeBindings = new ReferenceBinding[size];
297                         int count = 0;
298                         nextMember: for (int i = 0; i < size; i++) {
299                                 TypeDeclaration memberContext = referenceContext.memberTypes[i];
300                                 if (memberContext.isInterface() && sourceType.isNestedType()
301                                                 && sourceType.isClass() && !sourceType.isStatic()) {
302                                         problemReporter().nestedClassCannotDeclareInterface(
303                                                         memberContext);
304                                         continue nextMember;
305                                 }
306                                 ReferenceBinding type = sourceType;
307                                 // check that the member does not conflict with an enclosing
308                                 // type
309                                 do {
310                                         if (CharOperation.equals(type.sourceName,
311                                                         memberContext.name)) {
312                                                 problemReporter().hidingEnclosingType(memberContext);
313                                                 continue nextMember;
314                                         }
315                                         type = type.enclosingType();
316                                 } while (type != null);
317                                 // check that the member type does not conflict with another
318                                 // sibling member type
319                                 for (int j = 0; j < i; j++) {
320                                         if (CharOperation.equals(
321                                                         referenceContext.memberTypes[j].name,
322                                                         memberContext.name)) {
323                                                 problemReporter().duplicateNestedType(memberContext);
324                                                 continue nextMember;
325                                         }
326                                 }
327
328                                 ClassScope memberScope = new ClassScope(this, memberContext);
329                                 memberTypeBindings[count++] = memberScope.buildType(sourceType,
330                                                 packageBinding);
331                         }
332                         if (count != size)
333                                 System.arraycopy(memberTypeBindings, 0,
334                                                 memberTypeBindings = new ReferenceBinding[count], 0,
335                                                 count);
336                 }
337                 sourceType.memberTypes = memberTypeBindings;
338                 return sourceType;
339         }
340
341         private void checkAndSetModifiers() {
342                 SourceTypeBinding sourceType = referenceContext.binding;
343                 int modifiers = sourceType.modifiers;
344                 if ((modifiers & AccAlternateModifierProblem) != 0)
345                         problemReporter().duplicateModifierForType(sourceType);
346
347                 ReferenceBinding enclosingType = sourceType.enclosingType();
348                 boolean isMemberType = sourceType.isMemberType();
349
350                 if (isMemberType) {
351                         // checks for member types before local types to catch local members
352                         // if (enclosingType.isStrictfp())
353                         // modifiers |= AccStrictfp;
354                         if (enclosingType.isDeprecated())
355                                 modifiers |= AccDeprecatedImplicitly;
356                         if (enclosingType.isInterface())
357                                 modifiers |= AccPublic;
358                 } else if (sourceType.isLocalType()) {
359                         if (sourceType.isAnonymousType())
360                                 modifiers |= AccFinal;
361                         ReferenceContext refContext = methodScope().referenceContext;
362                         if (refContext instanceof TypeDeclaration) {
363                                 ReferenceBinding type = ((TypeDeclaration) refContext).binding;
364                                 // if (type.isStrictfp())
365                                 // modifiers |= AccStrictfp;
366                                 if (type.isDeprecated())
367                                         modifiers |= AccDeprecatedImplicitly;
368                         } else {
369                                 MethodBinding method = ((AbstractMethodDeclaration) refContext).binding;
370                                 if (method != null) {
371                                         // if (method.isStrictfp())
372                                         // modifiers |= AccStrictfp;
373                                         if (method.isDeprecated())
374                                                 modifiers |= AccDeprecatedImplicitly;
375                                 }
376                         }
377                 }
378                 // after this point, tests on the 16 bits reserved.
379                 int realModifiers = modifiers & AccJustFlag;
380
381                 if ((realModifiers & AccInterface) != 0) {
382                         // detect abnormal cases for interfaces
383                         if (isMemberType) {
384                                 int unexpectedModifiers = ~(AccPublic | AccPrivate
385                                                 | AccProtected | AccStatic | AccAbstract | AccInterface);// |
386                                                                                                                                                                         // AccStrictfp);
387                                 if ((realModifiers & unexpectedModifiers) != 0)
388                                         problemReporter().illegalModifierForMemberInterface(
389                                                         sourceType);
390                                 /*
391                                  * } else if (sourceType.isLocalType()) { //interfaces cannot be
392                                  * defined inside a method int unexpectedModifiers =
393                                  * ~(AccAbstract | AccInterface | AccStrictfp); if
394                                  * ((realModifiers & unexpectedModifiers) != 0)
395                                  * problemReporter().illegalModifierForLocalInterface(sourceType);
396                                  */
397                         } else {
398                                 int unexpectedModifiers = ~(AccPublic | AccAbstract | AccInterface);// |
399                                                                                                                                                                         // AccStrictfp);
400                                 if ((realModifiers & unexpectedModifiers) != 0)
401                                         problemReporter().illegalModifierForInterface(sourceType);
402                         }
403                         modifiers |= AccAbstract;
404                 } else {
405                         // detect abnormal cases for types
406                         if (isMemberType) { // includes member types defined inside local
407                                                                 // types
408                                 int unexpectedModifiers = ~(AccPublic | AccPrivate
409                                                 | AccProtected | AccStatic | AccAbstract | AccFinal);// |
410                                                                                                                                                                 // AccStrictfp);
411                                 if ((realModifiers & unexpectedModifiers) != 0)
412                                         problemReporter().illegalModifierForMemberClass(sourceType);
413                         } else if (sourceType.isLocalType()) {
414                                 int unexpectedModifiers = ~(AccAbstract | AccFinal);// |
415                                                                                                                                         // AccStrictfp);
416                                 if ((realModifiers & unexpectedModifiers) != 0)
417                                         problemReporter().illegalModifierForLocalClass(sourceType);
418                         } else {
419                                 int unexpectedModifiers = ~(AccPublic | AccAbstract | AccFinal);// |
420                                                                                                                                                                 // AccStrictfp);
421                                 if ((realModifiers & unexpectedModifiers) != 0)
422                                         problemReporter().illegalModifierForClass(sourceType);
423                         }
424
425                         // check that Final and Abstract are not set together
426                         if ((realModifiers & (AccFinal | AccAbstract)) == (AccFinal | AccAbstract))
427                                 problemReporter()
428                                                 .illegalModifierCombinationFinalAbstractForClass(
429                                                                 sourceType);
430                 }
431
432                 if (isMemberType) {
433                         // test visibility modifiers inconsistency, isolate the accessors
434                         // bits
435                         if (enclosingType.isInterface()) {
436                                 if ((realModifiers & (AccProtected | AccPrivate)) != 0) {
437                                         problemReporter()
438                                                         .illegalVisibilityModifierForInterfaceMemberType(
439                                                                         sourceType);
440
441                                         // need to keep the less restrictive
442                                         if ((realModifiers & AccProtected) != 0)
443                                                 modifiers ^= AccProtected;
444                                         if ((realModifiers & AccPrivate) != 0)
445                                                 modifiers ^= AccPrivate;
446                                 }
447                         } else {
448                                 int accessorBits = realModifiers
449                                                 & (AccPublic | AccProtected | AccPrivate);
450                                 if ((accessorBits & (accessorBits - 1)) > 1) {
451                                         problemReporter()
452                                                         .illegalVisibilityModifierCombinationForMemberType(
453                                                                         sourceType);
454
455                                         // need to keep the less restrictive
456                                         if ((accessorBits & AccPublic) != 0) {
457                                                 if ((accessorBits & AccProtected) != 0)
458                                                         modifiers ^= AccProtected;
459                                                 if ((accessorBits & AccPrivate) != 0)
460                                                         modifiers ^= AccPrivate;
461                                         }
462                                         if ((accessorBits & AccProtected) != 0)
463                                                 if ((accessorBits & AccPrivate) != 0)
464                                                         modifiers ^= AccPrivate;
465                                 }
466                         }
467
468                         // static modifier test
469                         if ((realModifiers & AccStatic) == 0) {
470                                 if (enclosingType.isInterface())
471                                         modifiers |= AccStatic;
472                         } else {
473                                 if (!enclosingType.isStatic())
474                                         // error the enclosing type of a static field must be static
475                                         // or a top-level type
476                                         problemReporter().illegalStaticModifierForMemberType(
477                                                         sourceType);
478                         }
479                 }
480
481                 sourceType.modifiers = modifiers;
482         }
483
484         /*
485          * This method checks the modifiers of a field.
486          * 
487          * 9.3 & 8.3 Need to integrate the check for the final modifiers for nested
488          * types
489          * 
490          * Note : A scope is accessible by : fieldBinding.declaringClass.scope
491          */
492         private void checkAndSetModifiersForField(FieldBinding fieldBinding,
493                         FieldDeclaration fieldDecl) {
494                 int modifiers = fieldBinding.modifiers;
495                 if ((modifiers & AccAlternateModifierProblem) != 0)
496                         problemReporter().duplicateModifierForField(
497                                         fieldBinding.declaringClass, fieldDecl);
498
499                 if (fieldBinding.declaringClass.isInterface()) {
500                         int expectedValue = AccPublic | AccStatic | AccFinal;
501                         // set the modifiers
502                         modifiers |= expectedValue;
503
504                         // and then check that they are the only ones
505                         if ((modifiers & AccJustFlag) != expectedValue)
506                                 problemReporter().illegalModifierForInterfaceField(
507                                                 fieldBinding.declaringClass, fieldDecl);
508                         fieldBinding.modifiers = modifiers;
509                         return;
510                 }
511
512                 // after this point, tests on the 16 bits reserved.
513                 int realModifiers = modifiers & AccJustFlag;
514                 int unexpectedModifiers = ~(AccPublic | AccPrivate | AccProtected
515                                 | AccFinal | AccStatic);// | AccTransient | AccVolatile);
516                 if ((realModifiers & unexpectedModifiers) != 0)
517                         problemReporter().illegalModifierForField(
518                                         fieldBinding.declaringClass, fieldDecl);
519
520                 int accessorBits = realModifiers
521                                 & (AccPublic | AccProtected | AccPrivate);
522                 if ((accessorBits & (accessorBits - 1)) > 1) {
523                         problemReporter().illegalVisibilityModifierCombinationForField(
524                                         fieldBinding.declaringClass, fieldDecl);
525
526                         // need to keep the less restrictive
527                         if ((accessorBits & AccPublic) != 0) {
528                                 if ((accessorBits & AccProtected) != 0)
529                                         modifiers ^= AccProtected;
530                                 if ((accessorBits & AccPrivate) != 0)
531                                         modifiers ^= AccPrivate;
532                         }
533                         if ((accessorBits & AccProtected) != 0)
534                                 if ((accessorBits & AccPrivate) != 0)
535                                         modifiers ^= AccPrivate;
536                 }
537
538                 // if ((realModifiers & (AccFinal | AccVolatile)) == (AccFinal |
539                 // AccVolatile))
540                 // problemReporter().illegalModifierCombinationFinalVolatileForField(
541                 // fieldBinding.declaringClass,
542                 // fieldDecl);
543
544                 if (fieldDecl.initialization == null && (modifiers & AccFinal) != 0) {
545                         modifiers |= AccBlankFinal;
546                 }
547                 fieldBinding.modifiers = modifiers;
548         }
549
550         private void checkForInheritedMemberTypes(SourceTypeBinding sourceType) {
551                 // search up the hierarchy of the sourceType to see if any superType
552                 // defines a member type
553                 // when no member types are defined, tag the sourceType & each superType
554                 // with the HasNoMemberTypes bit
555                 ReferenceBinding currentType = sourceType;
556                 ReferenceBinding[][] interfacesToVisit = null;
557                 int lastPosition = -1;
558                 do {
559                         if ((currentType.tagBits & HasNoMemberTypes) != 0)
560                                 break; // already know it has no inherited member types, can
561                                                 // stop looking up
562                         if (currentType.memberTypes() != NoMemberTypes)
563                                 return; // has member types
564                         ReferenceBinding[] itsInterfaces = currentType.superInterfaces();
565                         if (itsInterfaces != NoSuperInterfaces) {
566                                 if (interfacesToVisit == null)
567                                         interfacesToVisit = new ReferenceBinding[5][];
568                                 if (++lastPosition == interfacesToVisit.length)
569                                         System
570                                                         .arraycopy(
571                                                                         interfacesToVisit,
572                                                                         0,
573                                                                         interfacesToVisit = new ReferenceBinding[lastPosition * 2][],
574                                                                         0, lastPosition);
575                                 interfacesToVisit[lastPosition] = itsInterfaces;
576                         }
577                 } while ((currentType = currentType.superclass()) != null);
578
579                 boolean hasMembers = false;
580                 if (interfacesToVisit != null) {
581                         done: for (int i = 0; i <= lastPosition; i++) {
582                                 ReferenceBinding[] interfaces = interfacesToVisit[i];
583                                 for (int j = 0, length = interfaces.length; j < length; j++) {
584                                         ReferenceBinding anInterface = interfaces[j];
585                                         if ((anInterface.tagBits & InterfaceVisited) == 0) { // if
586                                                                                                                                                         // interface
587                                                                                                                                                         // as
588                                                                                                                                                         // not
589                                                                                                                                                         // already
590                                                                                                                                                         // been
591                                                                                                                                                         // visited
592                                                 anInterface.tagBits |= InterfaceVisited;
593                                                 if ((anInterface.tagBits & HasNoMemberTypes) != 0)
594                                                         continue; // already know it has no inherited
595                                                                                 // member types
596                                                 if (anInterface.memberTypes() != NoMemberTypes) {
597                                                         hasMembers = true;
598                                                         break done;
599                                                 }
600
601                                                 ReferenceBinding[] itsInterfaces = anInterface
602                                                                 .superInterfaces();
603                                                 if (itsInterfaces != NoSuperInterfaces) {
604                                                         if (++lastPosition == interfacesToVisit.length)
605                                                                 System
606                                                                                 .arraycopy(
607                                                                                                 interfacesToVisit,
608                                                                                                 0,
609                                                                                                 interfacesToVisit = new ReferenceBinding[lastPosition * 2][],
610                                                                                                 0, lastPosition);
611                                                         interfacesToVisit[lastPosition] = itsInterfaces;
612                                                 }
613                                         }
614                                 }
615                         }
616
617                         for (int i = 0; i <= lastPosition; i++) {
618                                 ReferenceBinding[] interfaces = interfacesToVisit[i];
619                                 for (int j = 0, length = interfaces.length; j < length; j++) {
620                                         interfaces[j].tagBits &= ~InterfaceVisited;
621                                         if (!hasMembers)
622                                                 interfaces[j].tagBits |= HasNoMemberTypes;
623                                 }
624                         }
625                 }
626
627                 if (!hasMembers) {
628                         currentType = sourceType;
629                         do {
630                                 currentType.tagBits |= HasNoMemberTypes;
631                         } while ((currentType = currentType.superclass()) != null);
632                 }
633         }
634
635         private void connectMemberTypes() {
636                 SourceTypeBinding sourceType = referenceContext.binding;
637                 if (sourceType.memberTypes != NoMemberTypes)
638                         for (int i = 0, size = sourceType.memberTypes.length; i < size; i++)
639                                 ((SourceTypeBinding) sourceType.memberTypes[i]).scope
640                                                 .connectTypeHierarchy();
641         }
642
643         /*
644          * Our current belief based on available JCK tests is: inherited member
645          * types are visible as a potential superclass. inherited interfaces are not
646          * visible when defining a superinterface.
647          * 
648          * Error recovery story: ensure the superclass is set to java.lang.Object if
649          * a problem is detected resolving the superclass.
650          * 
651          * Answer false if an error was reported against the sourceType.
652          */
653         private boolean connectSuperclass() {
654                 SourceTypeBinding sourceType = referenceContext.binding;
655                 if (isJavaLangObject(sourceType)) { // handle the case of redefining
656                                                                                         // java.lang.Object up front
657                         sourceType.superclass = null;
658                         sourceType.superInterfaces = NoSuperInterfaces;
659                         if (referenceContext.superclass != null
660                                         || referenceContext.superInterfaces != null)
661                                 problemReporter().objectCannotHaveSuperTypes(sourceType);
662                         return true; // do not propagate Object's hierarchy problems down
663                                                         // to every subtype
664                 }
665                 if (referenceContext.superclass == null) {
666                         sourceType.superclass = getJavaLangObject();
667                         return !detectCycle(sourceType, sourceType.superclass, null);
668                 }
669                 ReferenceBinding superclass = findSupertype(referenceContext.superclass);
670                 if (superclass != null) { // is null if a cycle was detected cycle
671                         if (!superclass.isValidBinding()) {
672                                 problemReporter().invalidSuperclass(sourceType,
673                                                 referenceContext.superclass, superclass);
674                         } else if (superclass.isInterface()) {
675                                 problemReporter().superclassMustBeAClass(sourceType,
676                                                 referenceContext.superclass, superclass);
677                         } else if (superclass.isFinal()) {
678                                 problemReporter().classExtendFinalClass(sourceType,
679                                                 referenceContext.superclass, superclass);
680                         } else {
681                                 // only want to reach here when no errors are reported
682                                 referenceContext.superclass.resolvedType = superclass;
683                                 sourceType.superclass = superclass;
684                                 return true;
685                         }
686                 }
687                 sourceType.tagBits |= HierarchyHasProblems;
688                 sourceType.superclass = getJavaLangObject();
689                 if ((sourceType.superclass.tagBits & BeginHierarchyCheck) == 0)
690                         detectCycle(sourceType, sourceType.superclass, null);
691                 return false; // reported some error against the source type
692         }
693
694         /*
695          * Our current belief based on available JCK 1.3 tests is: inherited member
696          * types are visible as a potential superclass. inherited interfaces are
697          * visible when defining a superinterface.
698          * 
699          * Error recovery story: ensure the superinterfaces contain only valid
700          * visible interfaces.
701          * 
702          * Answer false if an error was reported against the sourceType.
703          */
704         private boolean connectSuperInterfaces() {
705                 SourceTypeBinding sourceType = referenceContext.binding;
706                 sourceType.superInterfaces = NoSuperInterfaces;
707                 if (referenceContext.superInterfaces == null)
708                         return true;
709                 if (isJavaLangObject(sourceType)) // already handled the case of
710                                                                                         // redefining java.lang.Object
711                         return true;
712
713                 boolean noProblems = true;
714                 int length = referenceContext.superInterfaces.length;
715                 ReferenceBinding[] interfaceBindings = new ReferenceBinding[length];
716                 int count = 0;
717                 nextInterface: for (int i = 0; i < length; i++) {
718                         ReferenceBinding superInterface = findSupertype(referenceContext.superInterfaces[i]);
719                         if (superInterface == null) { // detected cycle
720                                 noProblems = false;
721                                 continue nextInterface;
722                         }
723                         if (!superInterface.isValidBinding()) {
724                                 problemReporter().invalidSuperinterface(sourceType,
725                                                 referenceContext.superInterfaces[i], superInterface);
726                                 sourceType.tagBits |= HierarchyHasProblems;
727                                 noProblems = false;
728                                 continue nextInterface;
729                         }
730                         // Check for a duplicate interface once the name is resolved,
731                         // otherwise we may be confused (ie : a.b.I and c.d.I)
732                         for (int k = 0; k < count; k++) {
733                                 if (interfaceBindings[k] == superInterface) {
734                                         // should this be treated as a warning?
735                                         problemReporter().duplicateSuperinterface(sourceType,
736                                                         referenceContext, superInterface);
737                                         continue nextInterface;
738                                 }
739                         }
740                         if (superInterface.isClass()) {
741                                 problemReporter().superinterfaceMustBeAnInterface(sourceType,
742                                                 referenceContext, superInterface);
743                                 sourceType.tagBits |= HierarchyHasProblems;
744                                 noProblems = false;
745                                 continue nextInterface;
746                         }
747
748                         referenceContext.superInterfaces[i].resolvedType = superInterface;
749                         // only want to reach here when no errors are reported
750                         interfaceBindings[count++] = superInterface;
751                 }
752                 // hold onto all correctly resolved superinterfaces
753                 if (count > 0) {
754                         if (count != length)
755                                 System.arraycopy(interfaceBindings, 0,
756                                                 interfaceBindings = new ReferenceBinding[count], 0,
757                                                 count);
758                         sourceType.superInterfaces = interfaceBindings;
759                 }
760                 return noProblems;
761         }
762
763         void connectTypeHierarchy() {
764                 SourceTypeBinding sourceType = referenceContext.binding;
765                 if ((sourceType.tagBits & BeginHierarchyCheck) == 0) {
766                         boolean noProblems = true;
767                         sourceType.tagBits |= BeginHierarchyCheck;
768                         if (sourceType.isClass())
769                                 noProblems &= connectSuperclass();
770                         noProblems &= connectSuperInterfaces();
771                         sourceType.tagBits |= EndHierarchyCheck;
772                         if (noProblems && sourceType.isHierarchyInconsistent())
773                                 problemReporter().hierarchyHasProblems(sourceType);
774                 }
775                 connectMemberTypes();
776                 checkForInheritedMemberTypes(sourceType);
777         }
778
779         private void connectTypeHierarchyWithoutMembers() {
780                 // must ensure the imports are resolved
781                 if (parent instanceof CompilationUnitScope) {
782                         // if (((CompilationUnitScope) parent).imports == null)
783                         // ((CompilationUnitScope) parent).checkAndSetImports();
784                 } else if (parent instanceof ClassScope) {
785                         // ensure that the enclosing type has already been checked
786                         ((ClassScope) parent).connectTypeHierarchyWithoutMembers();
787                 }
788
789                 // double check that the hierarchy search has not already begun...
790                 SourceTypeBinding sourceType = referenceContext.binding;
791                 if ((sourceType.tagBits & BeginHierarchyCheck) != 0)
792                         return;
793
794                 boolean noProblems = true;
795                 sourceType.tagBits |= BeginHierarchyCheck;
796                 if (sourceType.isClass())
797                         noProblems &= connectSuperclass();
798                 noProblems &= connectSuperInterfaces();
799                 sourceType.tagBits |= EndHierarchyCheck;
800                 if (noProblems && sourceType.isHierarchyInconsistent())
801                         problemReporter().hierarchyHasProblems(sourceType);
802         }
803
804         // Answer whether a cycle was found between the sourceType & the superType
805         private boolean detectCycle(SourceTypeBinding sourceType,
806                         ReferenceBinding superType, TypeReference reference) {
807                 if (sourceType == superType) {
808                         problemReporter().hierarchyCircularity(sourceType, superType,
809                                         reference);
810                         sourceType.tagBits |= HierarchyHasProblems;
811                         return true;
812                 }
813
814                 if (superType.isBinaryBinding()) {
815                         // force its superclass & superinterfaces to be found... 2
816                         // possibilities exist - the source type is included in the
817                         // hierarchy of:
818                         // - a binary type... this case MUST be caught & reported here
819                         // - another source type... this case is reported against the other
820                         // source type
821                         boolean hasCycle = false;
822                         if (superType.superclass() != null) {
823                                 if (sourceType == superType.superclass()) {
824                                         problemReporter().hierarchyCircularity(sourceType,
825                                                         superType, reference);
826                                         sourceType.tagBits |= HierarchyHasProblems;
827                                         superType.tagBits |= HierarchyHasProblems;
828                                         return true;
829                                 }
830                                 hasCycle |= detectCycle(sourceType, superType.superclass(),
831                                                 reference);
832                                 if ((superType.superclass().tagBits & HierarchyHasProblems) != 0) {
833                                         sourceType.tagBits |= HierarchyHasProblems;
834                                         superType.tagBits |= HierarchyHasProblems; // propagate
835                                                                                                                                 // down the
836                                                                                                                                 // hierarchy
837                                 }
838                         }
839
840                         ReferenceBinding[] itsInterfaces = superType.superInterfaces();
841                         if (itsInterfaces != NoSuperInterfaces) {
842                                 for (int i = 0, length = itsInterfaces.length; i < length; i++) {
843                                         ReferenceBinding anInterface = itsInterfaces[i];
844                                         if (sourceType == anInterface) {
845                                                 problemReporter().hierarchyCircularity(sourceType,
846                                                                 superType, reference);
847                                                 sourceType.tagBits |= HierarchyHasProblems;
848                                                 superType.tagBits |= HierarchyHasProblems;
849                                                 return true;
850                                         }
851                                         hasCycle |= detectCycle(sourceType, anInterface, reference);
852                                         if ((anInterface.tagBits & HierarchyHasProblems) != 0) {
853                                                 sourceType.tagBits |= HierarchyHasProblems;
854                                                 superType.tagBits |= HierarchyHasProblems;
855                                         }
856                                 }
857                         }
858                         return hasCycle;
859                 }
860
861                 if ((superType.tagBits & EndHierarchyCheck) == 0
862                                 && (superType.tagBits & BeginHierarchyCheck) != 0) {
863                         problemReporter().hierarchyCircularity(sourceType, superType,
864                                         reference);
865                         sourceType.tagBits |= HierarchyHasProblems;
866                         superType.tagBits |= HierarchyHasProblems;
867                         return true;
868                 }
869                 if ((superType.tagBits & BeginHierarchyCheck) == 0)
870                         // ensure if this is a source superclass that it has already been
871                         // checked
872                         ((SourceTypeBinding) superType).scope
873                                         .connectTypeHierarchyWithoutMembers();
874                 if ((superType.tagBits & HierarchyHasProblems) != 0)
875                         sourceType.tagBits |= HierarchyHasProblems;
876                 return false;
877         }
878
879         private ReferenceBinding findSupertype(TypeReference typeReference) {
880                 typeReference.aboutToResolve(this); // allows us to trap completion &
881                                                                                         // selection nodes
882                 char[][] compoundName = typeReference.getTypeName();
883                 compilationUnitScope().recordQualifiedReference(compoundName);
884                 SourceTypeBinding sourceType = referenceContext.binding;
885                 int size = compoundName.length;
886                 int n = 1;
887                 ReferenceBinding superType;
888
889                 // resolve the first name of the compoundName
890                 if (CharOperation.equals(compoundName[0], sourceType.sourceName)) {
891                         superType = sourceType;
892                         // match against the sourceType even though nested members cannot be
893                         // supertypes
894                 } else {
895                         Binding typeOrPackage = parent.getTypeOrPackage(compoundName[0],
896                                         TYPE | PACKAGE);
897                         if (typeOrPackage == null || !typeOrPackage.isValidBinding())
898                                 return new ProblemReferenceBinding(compoundName[0],
899                                                 typeOrPackage == null ? NotFound : typeOrPackage
900                                                                 .problemId());
901
902                         boolean checkVisibility = false;
903                         for (; n < size; n++) {
904                                 if (!(typeOrPackage instanceof PackageBinding))
905                                         break;
906                                 PackageBinding packageBinding = (PackageBinding) typeOrPackage;
907                                 typeOrPackage = packageBinding
908                                                 .getTypeOrPackage(compoundName[n]);
909                                 if (typeOrPackage == null || !typeOrPackage.isValidBinding())
910                                         return new ProblemReferenceBinding(CharOperation.subarray(
911                                                         compoundName, 0, n + 1),
912                                                         typeOrPackage == null ? NotFound : typeOrPackage
913                                                                         .problemId());
914                                 checkVisibility = true;
915                         }
916
917                         // convert to a ReferenceBinding
918                         if (typeOrPackage instanceof PackageBinding) // error, the
919                                                                                                                         // compoundName is a
920                                                                                                                         // packageName
921                                 return new ProblemReferenceBinding(CharOperation.subarray(
922                                                 compoundName, 0, n), NotFound);
923                         superType = (ReferenceBinding) typeOrPackage;
924                         compilationUnitScope().recordTypeReference(superType); // to record
925                                                                                                                                         // supertypes
926
927                         if (checkVisibility && n == size) { // if we're finished and know
928                                                                                                 // the final supertype then
929                                                                                                 // check visibility
930                                 if (!superType.canBeSeenBy(sourceType.fPackage))
931                                         // its a toplevel type so just check package access
932                                         return new ProblemReferenceBinding(CharOperation.subarray(
933                                                         compoundName, 0, n), superType, NotVisible);
934                         }
935                 }
936                 // at this point we know we have a type but we have to look for cycles
937                 while (true) {
938                         // must detect cycles & force connection up the hierarchy... also
939                         // handle cycles with binary types.
940                         // must be guaranteed that the superType knows its entire hierarchy
941                         if (detectCycle(sourceType, superType, typeReference))
942                                 return null; // cycle error was already reported
943
944                         if (n >= size)
945                                 break;
946
947                         // retrieve the next member type
948                         char[] typeName = compoundName[n++];
949                         superType = findMemberType(typeName, superType);
950                         if (superType == null)
951                                 return new ProblemReferenceBinding(CharOperation.subarray(
952                                                 compoundName, 0, n), NotFound);
953                         if (!superType.isValidBinding()) {
954                                 superType.compoundName = CharOperation.subarray(compoundName,
955                                                 0, n);
956                                 return superType;
957                         }
958                 }
959                 return superType;
960         }
961
962         /*
963          * Answer the problem reporter to use for raising new problems.
964          * 
965          * Note that as a side-effect, this updates the current reference context
966          * (unit, type or method) in case the problem handler decides it is
967          * necessary to abort.
968          */
969         public ProblemReporter problemReporter() {
970                 MethodScope outerMethodScope;
971                 if ((outerMethodScope = outerMostMethodScope()) == null) {
972                         ProblemReporter problemReporter = referenceCompilationUnit().problemReporter;
973                         problemReporter.referenceContext = referenceContext;
974                         return problemReporter;
975                 } else {
976                         return outerMethodScope.problemReporter();
977                 }
978         }
979
980         /*
981          * Answer the reference type of this scope. It is the nearest enclosing type
982          * of this scope.
983          */
984         public TypeDeclaration referenceType() {
985                 return referenceContext;
986         }
987
988         public String toString() {
989                 if (referenceContext != null)
990                         return "--- Class Scope ---\n\n" //$NON-NLS-1$
991                                         + referenceContext.binding.toString();
992                 else
993                         return "--- Class Scope ---\n\n Binding not initialized"; //$NON-NLS-1$
994         }
995 }