3m9 compatible;
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / lookup / CompilationUnitScope.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 java.util.ArrayList;
14
15 import net.sourceforge.phpdt.core.compiler.CharOperation;
16 import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
17 import net.sourceforge.phpdt.internal.compiler.util.CompoundNameVector;
18 import net.sourceforge.phpdt.internal.compiler.util.HashtableOfType;
19 import net.sourceforge.phpdt.internal.compiler.util.ObjectVector;
20 import net.sourceforge.phpdt.internal.compiler.util.SimpleNameVector;
21 import net.sourceforge.phpeclipse.internal.compiler.ast.CompilationUnitDeclaration;
22 import net.sourceforge.phpeclipse.internal.compiler.ast.ImportReference;
23 import net.sourceforge.phpeclipse.internal.compiler.ast.TypeDeclaration;
24
25 public class CompilationUnitScope extends Scope {
26
27   public LookupEnvironment environment;
28   public CompilationUnitDeclaration referenceContext;
29   public char[][] currentPackageName;
30   public PackageBinding fPackage;
31   public ImportBinding[] imports;
32
33   public SourceTypeBinding[] topLevelTypes;
34
35   private CompoundNameVector qualifiedReferences;
36   private SimpleNameVector simpleNameReferences;
37   private ObjectVector referencedTypes;
38
39   HashtableOfType constantPoolNameUsage;
40
41   public CompilationUnitScope(CompilationUnitDeclaration unit, LookupEnvironment environment) {
42     super(COMPILATION_UNIT_SCOPE, null);
43     this.environment = environment;
44     this.referenceContext = unit;
45     unit.scope = this;
46     this.currentPackageName = unit.currentPackage == null ? CharOperation.NO_CHAR_CHAR : unit.currentPackage.tokens;
47
48     //  if (environment.options.produceReferenceInfo) {
49     //          this.qualifiedReferences = new CompoundNameVector();
50     //          this.simpleNameReferences = new SimpleNameVector();
51     //          this.referencedTypes = new ObjectVector();
52     //  } else {
53     this.qualifiedReferences = null; // used to test if dependencies should be recorded
54     this.simpleNameReferences = null;
55     this.referencedTypes = null;
56     //  }
57   }
58   void buildFieldsAndMethods() {
59     for (int i = 0, length = topLevelTypes.length; i < length; i++)
60       topLevelTypes[i].scope.buildFieldsAndMethods();
61   }
62   void buildTypeBindings() {
63     if (referenceContext.compilationResult.compilationUnit != null) {
64       char[][] expectedPackageName = referenceContext.compilationResult.compilationUnit.getPackageName();
65       if (expectedPackageName != null && !CharOperation.equals(currentPackageName, expectedPackageName)) {
66
67         // only report if the unit isn't structurally empty
68         //                      if (referenceContext.currentPackage != null 
69         //                                      || referenceContext.types != null 
70         //                                      || referenceContext.imports != null) {
71         //                              problemReporter().packageIsNotExpectedPackage(referenceContext);
72         //                      }
73         currentPackageName = expectedPackageName.length == 0 ? CharOperation.NO_CHAR_CHAR : expectedPackageName;
74       }
75     }
76     if (currentPackageName == CharOperation.NO_CHAR_CHAR) {
77       if ((fPackage = environment.defaultPackage) == null) {
78         problemReporter().mustSpecifyPackage(referenceContext);
79         return;
80       }
81     } else {
82                 if ((fPackage = environment.createPackage(currentPackageName)) == null) {
83 //                              problemReporter().packageCollidesWithType(referenceContext);
84                         return;
85                 }
86       recordQualifiedReference(currentPackageName); // always dependent on your own package
87     }
88
89     // Skip typeDeclarations which know of previously reported errors
90     ArrayList types = referenceContext.types;
91     int typeLength = (types == null) ? 0 : types.size();
92     topLevelTypes = new SourceTypeBinding[typeLength];
93     int count = 0;
94     nextType : for (int i = 0; i < typeLength; i++) {
95       if (types.get(i) instanceof TypeDeclaration) {
96         TypeDeclaration typeDecl = (TypeDeclaration) types.get(i);
97         ReferenceBinding typeBinding = fPackage.getType0(typeDecl.name);
98         recordSimpleReference(typeDecl.name); // needed to detect collision cases
99         if (typeBinding != null && !(typeBinding instanceof UnresolvedReferenceBinding)) {
100           // if a type exists, it must be a valid type - cannot be a NotFound problem type
101           // unless its an unresolved type which is now being defined
102           problemReporter().duplicateTypes(referenceContext, typeDecl);
103           continue nextType;
104         }
105         if (fPackage != environment.defaultPackage && fPackage.getPackage(typeDecl.name) != null) {
106           // if a package exists, it must be a valid package - cannot be a NotFound problem package
107           problemReporter().typeCollidesWithPackage(referenceContext, typeDecl);
108           continue nextType;
109         }
110
111         if ((typeDecl.modifiers & AccPublic) != 0) {
112           char[] mainTypeName;
113             if ((mainTypeName = referenceContext.getMainTypeName()) != null
114             // mainTypeName == null means that implementor of ICompilationUnit decided to return null
115               && !CharOperation.equals(mainTypeName, typeDecl.name)) {
116             problemReporter().publicClassMustMatchFileName(referenceContext, typeDecl);
117             continue nextType;
118           }
119         }
120
121         ClassScope child = new ClassScope(this, typeDecl);
122         SourceTypeBinding type = child.buildType(null, fPackage);
123         if (type != null) {
124           topLevelTypes[count++] = type;
125         }
126       }
127     }
128
129     // shrink topLevelTypes... only happens if an error was reported
130     if (count != topLevelTypes.length)
131       System.arraycopy(topLevelTypes, 0, topLevelTypes = new SourceTypeBinding[count], 0, count);
132   }
133   void checkAndSetImports() {
134     // initialize the default imports if necessary... share the default java.lang.* import
135     if (environment.defaultImports == null) {
136       Binding importBinding = environment.getTopLevelPackage(JAVA);
137       if (importBinding != null)
138         importBinding = ((PackageBinding) importBinding).getTypeOrPackage(JAVA_LANG[1]);
139
140       // abort if java.lang cannot be found...
141       if (importBinding == null || !importBinding.isValidBinding())
142         problemReporter().isClassPathCorrect(JAVA_LANG_OBJECT, referenceCompilationUnit());
143
144       environment.defaultImports = new ImportBinding[] { new ImportBinding(JAVA_LANG, true, importBinding, null)};
145     }
146     if (referenceContext.imports == null) {
147       imports = environment.defaultImports;
148       return;
149     }
150
151     // allocate the import array, add java.lang.* by default
152     int numberOfStatements = referenceContext.imports.length;
153     int numberOfImports = numberOfStatements + 1;
154     for (int i = 0; i < numberOfStatements; i++) {
155       ImportReference importReference = referenceContext.imports[i];
156       if (importReference.onDemand && CharOperation.equals(JAVA_LANG, importReference.tokens)) {
157         numberOfImports--;
158         break;
159       }
160     }
161     ImportBinding[] resolvedImports = new ImportBinding[numberOfImports];
162     resolvedImports[0] = environment.defaultImports[0];
163     int index = 1;
164
165     nextImport : for (int i = 0; i < numberOfStatements; i++) {
166       ImportReference importReference = referenceContext.imports[i];
167       char[][] compoundName = importReference.tokens;
168
169       // skip duplicates or imports of the current package
170       for (int j = 0; j < index; j++)
171         if (resolvedImports[j].onDemand == importReference.onDemand)
172           if (CharOperation.equals(compoundName, resolvedImports[j].compoundName))
173             continue nextImport;
174       if (importReference.onDemand == true)
175         if (CharOperation.equals(compoundName, currentPackageName))
176           continue nextImport;
177
178       if (importReference.onDemand) {
179         Binding importBinding = findOnDemandImport(compoundName);
180         if (!importBinding.isValidBinding())
181           continue nextImport; // we report all problems in faultInImports()
182         resolvedImports[index++] = new ImportBinding(compoundName, true, importBinding, importReference);
183       } else {
184         resolvedImports[index++] = new ImportBinding(compoundName, false, null, importReference);
185       }
186     }
187
188     // shrink resolvedImports... only happens if an error was reported
189     if (resolvedImports.length > index)
190       System.arraycopy(resolvedImports, 0, resolvedImports = new ImportBinding[index], 0, index);
191     imports = resolvedImports;
192   }
193   /*
194    * INTERNAL USE-ONLY
195    * Innerclasses get their name computed as they are generated, since some may not
196    * be actually outputed if sitting inside unreachable code.
197    */
198   public char[] computeConstantPoolName(LocalTypeBinding localType) {
199     if (localType.constantPoolName() != null) {
200       return localType.constantPoolName();
201     }
202     // delegates to the outermost enclosing classfile, since it is the only one with a global vision of its innertypes.
203
204     if (constantPoolNameUsage == null)
205       constantPoolNameUsage = new HashtableOfType();
206
207     ReferenceBinding outerMostEnclosingType = localType.scope.outerMostClassScope().enclosingSourceType();
208
209     // ensure there is not already such a local type name defined by the user
210     int index = 0;
211     char[] candidateName;
212     while (true) {
213       if (localType.isMemberType()) {
214         if (index == 0) {
215           candidateName = CharOperation.concat(localType.enclosingType().constantPoolName(), localType.sourceName, '$');
216         } else {
217           // in case of collision, then member name gets extra $1 inserted
218           // e.g. class X { { class L{} new X(){ class L{} } } }
219           candidateName =
220             CharOperation.concat(localType.enclosingType().constantPoolName(), '$', String.valueOf(index).toCharArray(), '$', localType.sourceName);
221         }
222       } else if (localType.isAnonymousType()) {
223         candidateName = CharOperation.concat(outerMostEnclosingType.constantPoolName(), String.valueOf(index + 1).toCharArray(), '$');
224       } else {
225         candidateName =
226           CharOperation.concat(outerMostEnclosingType.constantPoolName(), '$', String.valueOf(index + 1).toCharArray(), '$', localType.sourceName);
227       }
228       if (constantPoolNameUsage.get(candidateName) != null) {
229         index++;
230       } else {
231         constantPoolNameUsage.put(candidateName, localType);
232         break;
233       }
234     }
235     return candidateName;
236   }
237
238   void connectTypeHierarchy() {
239     for (int i = 0, length = topLevelTypes.length; i < length; i++)
240       topLevelTypes[i].scope.connectTypeHierarchy();
241   }
242   void faultInImports() {
243     if (referenceContext.imports == null)
244       return;
245
246     // collect the top level type names if a single type import exists
247     int numberOfStatements = referenceContext.imports.length;
248     HashtableOfType typesBySimpleNames = null;
249     for (int i = 0; i < numberOfStatements; i++) {
250       if (!referenceContext.imports[i].onDemand) {
251         typesBySimpleNames = new HashtableOfType(topLevelTypes.length + numberOfStatements);
252         for (int j = 0, length = topLevelTypes.length; j < length; j++)
253           typesBySimpleNames.put(topLevelTypes[j].sourceName, topLevelTypes[j]);
254         break;
255       }
256     }
257
258     // allocate the import array, add java.lang.* by default
259     int numberOfImports = numberOfStatements + 1;
260     for (int i = 0; i < numberOfStatements; i++) {
261       ImportReference importReference = referenceContext.imports[i];
262       if (importReference.onDemand && CharOperation.equals(JAVA_LANG, importReference.tokens)) {
263         numberOfImports--;
264         break;
265       }
266     }
267     ImportBinding[] resolvedImports = new ImportBinding[numberOfImports];
268     resolvedImports[0] = environment.defaultImports[0];
269     int index = 1;
270
271     nextImport : for (int i = 0; i < numberOfStatements; i++) {
272       ImportReference importReference = referenceContext.imports[i];
273       char[][] compoundName = importReference.tokens;
274
275       // skip duplicates or imports of the current package
276       for (int j = 0; j < index; j++)
277         if (resolvedImports[j].onDemand == importReference.onDemand)
278           if (CharOperation.equals(compoundName, resolvedImports[j].compoundName)) {
279             problemReporter().unusedImport(importReference); // since skipped, must be reported now
280             continue nextImport;
281           }
282       if (importReference.onDemand == true)
283         if (CharOperation.equals(compoundName, currentPackageName)) {
284           problemReporter().unusedImport(importReference); // since skipped, must be reported now
285           continue nextImport;
286         }
287       if (importReference.onDemand) {
288         Binding importBinding = findOnDemandImport(compoundName);
289         if (!importBinding.isValidBinding()) {
290           problemReporter().importProblem(importReference, importBinding);
291           continue nextImport;
292         }
293         resolvedImports[index++] = new ImportBinding(compoundName, true, importBinding, importReference);
294       } else {
295         Binding typeBinding = findSingleTypeImport(compoundName);
296         if (!typeBinding.isValidBinding()) {
297           problemReporter().importProblem(importReference, typeBinding);
298           continue nextImport;
299         }
300         if (typeBinding instanceof PackageBinding) {
301           problemReporter().cannotImportPackage(importReference);
302           continue nextImport;
303         }
304         if (typeBinding instanceof ReferenceBinding) {
305           ReferenceBinding referenceBinding = (ReferenceBinding) typeBinding;
306           if (importReference.isTypeUseDeprecated(referenceBinding, this)) {
307             problemReporter().deprecatedType((TypeBinding) typeBinding, importReference);
308           }
309         }
310         ReferenceBinding existingType = typesBySimpleNames.get(compoundName[compoundName.length - 1]);
311         if (existingType != null) {
312           // duplicate test above should have caught this case, but make sure
313           if (existingType == typeBinding) {
314             continue nextImport;
315           }
316           // either the type collides with a top level type or another imported type
317           for (int j = 0, length = topLevelTypes.length; j < length; j++) {
318             if (CharOperation.equals(topLevelTypes[j].sourceName, existingType.sourceName)) {
319               problemReporter().conflictingImport(importReference);
320               continue nextImport;
321             }
322           }
323           problemReporter().duplicateImport(importReference);
324           continue nextImport;
325         }
326         resolvedImports[index++] = new ImportBinding(compoundName, false, typeBinding, importReference);
327         typesBySimpleNames.put(compoundName[compoundName.length - 1], (ReferenceBinding) typeBinding);
328       }
329     }
330
331     // shrink resolvedImports... only happens if an error was reported
332     if (resolvedImports.length > index)
333       System.arraycopy(resolvedImports, 0, resolvedImports = new ImportBinding[index], 0, index);
334     imports = resolvedImports;
335   }
336   public void faultInTypes() {
337     faultInImports();
338     if (topLevelTypes==null) {
339                         topLevelTypes = new SourceTypeBinding[0];
340     }
341     for (int i = 0, length = topLevelTypes.length; i < length; i++)
342       topLevelTypes[i].faultInTypesForFieldsAndMethods();
343   }
344   private Binding findOnDemandImport(char[][] compoundName) {
345     recordQualifiedReference(compoundName);
346
347     Binding binding = environment.getTopLevelPackage(compoundName[0]);
348     int i = 1;
349     int length = compoundName.length;
350     foundNothingOrType : if (binding != null) {
351       PackageBinding packageBinding = (PackageBinding) binding;
352       while (i < length) {
353         binding = packageBinding.getTypeOrPackage(compoundName[i++]);
354         if (binding == null || !binding.isValidBinding()) {
355           binding = null;
356           break foundNothingOrType;
357         }
358         if (!(binding instanceof PackageBinding))
359           break foundNothingOrType;
360
361         packageBinding = (PackageBinding) binding;
362       }
363       return packageBinding;
364     }
365
366     ReferenceBinding type;
367     if (binding == null) {
368       //                if (environment.defaultPackage == null
369       //                                || environment.options.complianceLevel >= CompilerOptions.JDK1_4){
370       //                        return new ProblemReferenceBinding(
371       //                                CharOperation.subarray(compoundName, 0, i),
372       //                                NotFound);
373       //                }
374       type = findType(compoundName[0], environment.defaultPackage, environment.defaultPackage);
375       if (type == null || !type.isValidBinding())
376         return new ProblemReferenceBinding(CharOperation.subarray(compoundName, 0, i), NotFound);
377       i = 1; // reset to look for member types inside the default package type
378     } else {
379       type = (ReferenceBinding) binding;
380     }
381
382     for (; i < length; i++) {
383       if (!type.canBeSeenBy(fPackage)) {
384         return new ProblemReferenceBinding(CharOperation.subarray(compoundName, 0, i), type, NotVisible);
385       }
386       // does not look for inherited member types on purpose
387       if ((type = type.getMemberType(compoundName[i])) == null) {
388         return new ProblemReferenceBinding(CharOperation.subarray(compoundName, 0, i + 1), NotFound);
389       }
390     }
391     if (!type.canBeSeenBy(fPackage))
392       return new ProblemReferenceBinding(compoundName, type, NotVisible);
393     return type;
394   }
395   private Binding findSingleTypeImport(char[][] compoundName) {
396     if (compoundName.length == 1) {
397       // findType records the reference
398       // the name cannot be a package
399       //                if (environment.defaultPackage == null 
400       //                        || environment.options.complianceLevel >= CompilerOptions.JDK1_4)
401       //                        return new ProblemReferenceBinding(compoundName, NotFound);
402       ReferenceBinding typeBinding = findType(compoundName[0], environment.defaultPackage, fPackage);
403       if (typeBinding == null)
404         return new ProblemReferenceBinding(compoundName, NotFound);
405       else
406         return typeBinding;
407     }
408     return findOnDemandImport(compoundName);
409   }
410   /* Answer the problem reporter to use for raising new problems.
411   *
412   * Note that as a side-effect, this updates the current reference context
413   * (unit, type or method) in case the problem handler decides it is necessary
414   * to abort.
415   */
416
417   public ProblemReporter problemReporter() {
418     ProblemReporter problemReporter = referenceContext.problemReporter;
419     problemReporter.referenceContext = referenceContext;
420     return problemReporter;
421   }
422
423   /*
424   What do we hold onto:
425   
426   1. when we resolve 'a.b.c', say we keep only 'a.b.c'
427    & when we fail to resolve 'c' in 'a.b', lets keep 'a.b.c'
428   THEN when we come across a new/changed/removed item named 'a.b.c',
429    we would find all references to 'a.b.c'
430   -> This approach fails because every type is resolved in every onDemand import to
431    detect collision cases... so the references could be 10 times bigger than necessary.
432   
433   2. when we resolve 'a.b.c', lets keep 'a.b' & 'c'
434    & when we fail to resolve 'c' in 'a.b', lets keep 'a.b' & 'c'
435   THEN when we come across a new/changed/removed item named 'a.b.c',
436    we would find all references to 'a.b' & 'c'
437   -> This approach does not have a space problem but fails to handle collision cases.
438    What happens if a type is added named 'a.b'? We would search for 'a' & 'b' but
439    would not find a match.
440   
441   3. when we resolve 'a.b.c', lets keep 'a', 'a.b' & 'a', 'b', 'c'
442    & when we fail to resolve 'c' in 'a.b', lets keep 'a', 'a.b' & 'a', 'b', 'c'
443   THEN when we come across a new/changed/removed item named 'a.b.c',
444    we would find all references to 'a.b' & 'c'
445   OR 'a.b' -> 'a' & 'b'
446   OR 'a' -> '' & 'a'
447   -> As long as each single char[] is interned, we should not have a space problem
448    and can handle collision cases.
449   
450   4. when we resolve 'a.b.c', lets keep 'a.b' & 'a', 'b', 'c'
451    & when we fail to resolve 'c' in 'a.b', lets keep 'a.b' & 'a', 'b', 'c'
452   THEN when we come across a new/changed/removed item named 'a.b.c',
453    we would find all references to 'a.b' & 'c'
454   OR 'a.b' -> 'a' & 'b' in the simple name collection
455   OR 'a' -> 'a' in the simple name collection
456   -> As long as each single char[] is interned, we should not have a space problem
457    and can handle collision cases.
458   */
459   void recordQualifiedReference(char[][] qualifiedName) {
460     if (qualifiedReferences == null)
461       return; // not recording dependencies
462
463     int length = qualifiedName.length;
464     if (length > 1) {
465       while (!qualifiedReferences.contains(qualifiedName)) {
466         qualifiedReferences.add(qualifiedName);
467         if (length == 2) {
468           recordSimpleReference(qualifiedName[0]);
469           recordSimpleReference(qualifiedName[1]);
470           return;
471         }
472         length--;
473         recordSimpleReference(qualifiedName[length]);
474         System.arraycopy(qualifiedName, 0, qualifiedName = new char[length][], 0, length);
475       }
476     } else if (length == 1) {
477       recordSimpleReference(qualifiedName[0]);
478     }
479   }
480   void recordReference(char[][] qualifiedEnclosingName, char[] simpleName) {
481     recordQualifiedReference(qualifiedEnclosingName);
482     recordSimpleReference(simpleName);
483   }
484   void recordSimpleReference(char[] simpleName) {
485     if (simpleNameReferences == null)
486       return; // not recording dependencies
487
488     if (!simpleNameReferences.contains(simpleName))
489       simpleNameReferences.add(simpleName);
490   }
491   void recordTypeReference(TypeBinding type) {
492     if (referencedTypes == null)
493       return; // not recording dependencies
494
495     if (type.isArrayType())
496       type = ((ArrayBinding) type).leafComponentType;
497     if (!type.isBaseType() && !referencedTypes.containsIdentical(type))
498       referencedTypes.add(type);
499   }
500   void recordTypeReferences(TypeBinding[] types) {
501     if (qualifiedReferences == null)
502       return; // not recording dependencies
503     if (types == null || types.length == 0)
504       return;
505
506     for (int i = 0, max = types.length; i < max; i++) {
507       // No need to record supertypes of method arguments & thrown exceptions, just the compoundName
508       // If a field/method is retrieved from such a type then a separate call does the job
509       TypeBinding type = types[i];
510       if (type.isArrayType())
511         type = ((ArrayBinding) type).leafComponentType;
512       if (!type.isBaseType()) {
513         ReferenceBinding actualType = (ReferenceBinding) type;
514         if (!actualType.isLocalType())
515           recordQualifiedReference(actualType.isMemberType() ? CharOperation.splitOn('.', actualType.readableName()) : actualType.compoundName);
516       }
517     }
518   }
519   Binding resolveSingleTypeImport(ImportBinding importBinding) {
520     if (importBinding.resolvedImport == null) {
521       importBinding.resolvedImport = findSingleTypeImport(importBinding.compoundName);
522       if (!importBinding.resolvedImport.isValidBinding() || importBinding.resolvedImport instanceof PackageBinding) {
523         if (this.imports != null) {
524           ImportBinding[] newImports = new ImportBinding[imports.length - 1];
525           for (int i = 0, n = 0, max = this.imports.length; i < max; i++)
526             if (this.imports[i] != importBinding) {
527               newImports[n++] = this.imports[i];
528             }
529           this.imports = newImports;
530         }
531         return null;
532       }
533     }
534     return importBinding.resolvedImport;
535   }
536   public void storeDependencyInfo() {
537     // add the type hierarchy of each referenced type
538     // cannot do early since the hierarchy may not be fully resolved
539     for (int i = 0; i < referencedTypes.size; i++) { // grows as more types are added
540       ReferenceBinding type = (ReferenceBinding) referencedTypes.elementAt(i);
541       if (!type.isLocalType()) {
542         recordQualifiedReference(type.isMemberType() ? CharOperation.splitOn('.', type.readableName()) : type.compoundName);
543         ReferenceBinding enclosing = type.enclosingType();
544         if (enclosing != null && !referencedTypes.containsIdentical(enclosing))
545           referencedTypes.add(enclosing); // to record its supertypes
546       }
547       ReferenceBinding superclass = type.superclass();
548       if (superclass != null && !referencedTypes.containsIdentical(superclass))
549         referencedTypes.add(superclass); // to record its supertypes
550       ReferenceBinding[] interfaces = type.superInterfaces();
551       if (interfaces != null && interfaces.length > 0)
552         for (int j = 0, length = interfaces.length; j < length; j++)
553           if (!referencedTypes.containsIdentical(interfaces[j]))
554             referencedTypes.add(interfaces[j]); // to record its supertypes
555     }
556
557     int size = qualifiedReferences.size;
558     char[][][] qualifiedRefs = new char[size][][];
559     for (int i = 0; i < size; i++)
560       qualifiedRefs[i] = qualifiedReferences.elementAt(i);
561     referenceContext.compilationResult.qualifiedReferences = qualifiedRefs;
562
563     size = simpleNameReferences.size;
564     char[][] simpleRefs = new char[size][];
565     for (int i = 0; i < size; i++)
566       simpleRefs[i] = simpleNameReferences.elementAt(i);
567     referenceContext.compilationResult.simpleNameReferences = simpleRefs;
568   }
569   public String toString() {
570     return "--- CompilationUnit Scope : " + new String(referenceContext.getFileName()); //$NON-NLS-1$
571   }
572   public void verifyMethods(MethodVerifier verifier) {
573     for (int i = 0, length = topLevelTypes.length; i < length; i++)
574       topLevelTypes[i].verifyMethods(verifier);
575   }
576 }