Fix nasty bug #706. See trac.
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / lookup / LookupEnvironment.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.CompilationUnitDeclaration;
15 import net.sourceforge.phpdt.internal.compiler.env.IBinaryType;
16 import net.sourceforge.phpdt.internal.compiler.env.INameEnvironment;
17 import net.sourceforge.phpdt.internal.compiler.env.NameEnvironmentAnswer;
18 import net.sourceforge.phpdt.internal.compiler.impl.ITypeRequestor;
19 import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
20 import net.sourceforge.phpdt.internal.compiler.util.HashtableOfPackage;
21 import net.sourceforge.phpdt.internal.compiler.util.Util;
22
23 public class LookupEnvironment implements BaseTypes, ProblemReasons,
24                 TypeConstants {
25         // public CompilerOptions options;
26         public ProblemReporter problemReporter;
27
28         public ITypeRequestor typeRequestor;
29
30         PackageBinding defaultPackage;
31
32         ImportBinding[] defaultImports;
33
34         HashtableOfPackage knownPackages;
35
36         static final ProblemPackageBinding TheNotFoundPackage = new ProblemPackageBinding(
37                         CharOperation.NO_CHAR, NotFound);
38
39         static final ProblemReferenceBinding TheNotFoundType = new ProblemReferenceBinding(
40                         CharOperation.NO_CHAR, NotFound);
41
42         private INameEnvironment nameEnvironment;
43
44         private MethodVerifier verifier;
45
46         private ArrayBinding[][] uniqueArrayBindings;
47
48         private CompilationUnitDeclaration[] units = new CompilationUnitDeclaration[4];
49
50         private int lastUnitIndex = -1;
51
52         private int lastCompletedUnitIndex = -1;
53
54         // indicate in which step on the compilation we are.
55         // step 1 : build the reference binding
56         // step 2 : conect the hierarchy (connect bindings)
57         // step 3 : build fields and method bindings.
58         private int stepCompleted;
59
60         final static int BUILD_TYPE_HIERARCHY = 1;
61
62         final static int CHECK_AND_SET_IMPORTS = 2;
63
64         final static int CONNECT_TYPE_HIERARCHY = 3;
65
66         final static int BUILD_FIELDS_AND_METHODS = 4;
67
68         public LookupEnvironment(ITypeRequestor typeRequestor,
69                         ProblemReporter problemReporter, INameEnvironment nameEnvironment) {
70                 // CompilerOptions options, ProblemReporter problemReporter,
71                 // INameEnvironment nameEnvironment) {
72                 this.typeRequestor = typeRequestor;
73                 // this.options = options;
74                 this.problemReporter = problemReporter;
75                 this.defaultPackage = new PackageBinding(this); // assume the default
76                                                                                                                 // package always exists
77                 this.defaultImports = null;
78                 this.nameEnvironment = nameEnvironment;
79                 this.knownPackages = new HashtableOfPackage();
80                 this.uniqueArrayBindings = new ArrayBinding[5][];
81                 this.uniqueArrayBindings[0] = new ArrayBinding[50]; // start off the
82                                                                                                                         // most common 1
83                                                                                                                         // dimension array @
84                                                                                                                         // 50
85         }
86
87         /*
88          * Ask the oracle for a type which corresponds to the compoundName. Answer
89          * null if the name cannot be found.
90          */
91
92         public ReferenceBinding askForType(char[][] compoundName) {
93                 NameEnvironmentAnswer answer = nameEnvironment.findType(compoundName);
94                 if (answer == null)
95                         return null;
96
97                 if (answer.isBinaryType())
98                         // the type was found as a .class file
99                         typeRequestor.accept(answer.getBinaryType(),
100                                         computePackageFrom(compoundName));
101                 else if (answer.isCompilationUnit())
102                         // the type was found as a .java file, try to build it then search
103                         // the cache
104                         typeRequestor.accept(answer.getCompilationUnit());
105                 else if (answer.isSourceType())
106                         // the type was found as a source model
107                         typeRequestor.accept(answer.getSourceTypes(),
108                                         computePackageFrom(compoundName));
109
110                 return getCachedType(compoundName);
111         }
112
113         /*
114          * Ask the oracle for a type named name in the packageBinding. Answer null
115          * if the name cannot be found.
116          */
117
118         ReferenceBinding askForType(PackageBinding packageBinding, char[] name) {
119                 if (packageBinding == null) {
120                         if (defaultPackage == null)
121                                 return null;
122                         packageBinding = defaultPackage;
123                 }
124                 NameEnvironmentAnswer answer = nameEnvironment.findType(name,
125                                 packageBinding.compoundName);
126                 if (answer == null)
127                         return null;
128
129                 if (answer.isBinaryType())
130                         // the type was found as a .class file
131                         typeRequestor.accept(answer.getBinaryType(), packageBinding);
132                 else if (answer.isCompilationUnit())
133                         // the type was found as a .java file, try to build it then search
134                         // the cache
135                         typeRequestor.accept(answer.getCompilationUnit());
136                 else if (answer.isSourceType())
137                         // the type was found as a source model
138                         typeRequestor.accept(answer.getSourceTypes(), packageBinding);
139
140                 return packageBinding.getType0(name);
141         }
142
143         /*
144          * Create the initial type bindings for the compilation unit.
145          * 
146          * See completeTypeBindings() for a description of the remaining steps
147          * 
148          * NOTE: This method can be called multiple times as additional source files
149          * are needed
150          */
151
152         public void buildTypeBindings(CompilationUnitDeclaration unit) {
153                 CompilationUnitScope scope = new CompilationUnitScope(unit, this);
154                 scope.buildTypeBindings();
155
156                 int unitsLength = units.length;
157                 if (++lastUnitIndex >= unitsLength)
158                         System.arraycopy(units, 0,
159                                         units = new CompilationUnitDeclaration[2 * unitsLength], 0,
160                                         unitsLength);
161                 units[lastUnitIndex] = unit;
162         }
163
164         /*
165          * Cache the binary type since we know it is needed during this compile.
166          * 
167          * Answer the created BinaryTypeBinding or null if the type is already in
168          * the cache.
169          */
170
171         public BinaryTypeBinding cacheBinaryType(IBinaryType binaryType) {
172                 return cacheBinaryType(binaryType, true);
173         }
174
175         /*
176          * Cache the binary type since we know it is needed during this compile.
177          * 
178          * Answer the created BinaryTypeBinding or null if the type is already in
179          * the cache.
180          */
181
182         public BinaryTypeBinding cacheBinaryType(IBinaryType binaryType,
183                         boolean needFieldsAndMethods) {
184                 char[][] compoundName = CharOperation
185                                 .splitOn('/', binaryType.getName());
186                 ReferenceBinding existingType = getCachedType(compoundName);
187
188                 if (existingType == null
189                                 || existingType instanceof UnresolvedReferenceBinding)
190                         // only add the binary type if its not already in the cache
191                         return createBinaryTypeFrom(binaryType,
192                                         computePackageFrom(compoundName), needFieldsAndMethods);
193                 return null; // the type already exists & can be retrieved from the
194                                                 // cache
195         }
196
197         /*
198          * 1. Connect the type hierarchy for the type bindings created for
199          * parsedUnits. 2. Create the field bindings 3. Create the method bindings
200          */
201
202         /*
203          * We know each known compilationUnit is free of errors at this point...
204          * 
205          * Each step will create additional bindings unless a problem is detected,
206          * in which case either the faulty import/superinterface/field/method will
207          * be skipped or a suitable replacement will be substituted (such as Object
208          * for a missing superclass)
209          */
210
211         public void completeTypeBindings() {
212                 stepCompleted = BUILD_TYPE_HIERARCHY;
213
214                 // for (int i = lastCompletedUnitIndex + 1; i <= lastUnitIndex; i++) {
215                 // units[i].scope.checkAndSetImports();
216                 // }
217                 stepCompleted = CHECK_AND_SET_IMPORTS;
218
219                 // for (int i = lastCompletedUnitIndex + 1; i <= lastUnitIndex; i++) {
220                 // units[i].scope.connectTypeHierarchy();
221                 // }
222                 stepCompleted = CONNECT_TYPE_HIERARCHY;
223
224                 for (int i = lastCompletedUnitIndex + 1; i <= lastUnitIndex; i++) {
225                         // units[i].scope.buildFieldsAndMethods();
226                         units[i] = null; // release unnecessary reference to the parsed
227                                                                 // unit
228                 }
229                 stepCompleted = BUILD_FIELDS_AND_METHODS;
230                 lastCompletedUnitIndex = lastUnitIndex;
231         }
232
233         /*
234          * 1. Connect the type hierarchy for the type bindings created for
235          * parsedUnits. 2. Create the field bindings 3. Create the method bindings
236          */
237
238         /*
239          * Each step will create additional bindings unless a problem is detected,
240          * in which case either the faulty import/superinterface/field/method will
241          * be skipped or a suitable replacement will be substituted (such as Object
242          * for a missing superclass)
243          */
244
245         public void completeTypeBindings(CompilationUnitDeclaration parsedUnit) {
246                 if (stepCompleted == BUILD_FIELDS_AND_METHODS) {
247                         // This can only happen because the original set of units are
248                         // completely built and
249                         // are now being processed, so we want to treat all the additional
250                         // units as a group
251                         // until they too are completely processed.
252                         completeTypeBindings();
253                 } else {
254                         if (parsedUnit.scope == null)
255                                 return; // parsing errors were too severe
256
257                         // if (stepCompleted >= CHECK_AND_SET_IMPORTS)
258                         // parsedUnit.scope.checkAndSetImports();
259
260                         if (stepCompleted >= CONNECT_TYPE_HIERARCHY)
261                                 parsedUnit.scope.connectTypeHierarchy();
262                 }
263         }
264
265         /*
266          * Used by other compiler tools which do not start by calling
267          * completeTypeBindings().
268          * 
269          * 1. Connect the type hierarchy for the type bindings created for
270          * parsedUnits. 2. Create the field bindings 3. Create the method bindings
271          */
272
273         public void completeTypeBindings(CompilationUnitDeclaration parsedUnit,
274                         boolean buildFieldsAndMethods) {
275                 if (parsedUnit.scope == null)
276                         return; // parsing errors were too severe
277
278                 parsedUnit.scope.checkAndSetImports();
279                 parsedUnit.scope.connectTypeHierarchy();
280
281                 if (buildFieldsAndMethods)
282                         parsedUnit.scope.buildFieldsAndMethods();
283         }
284
285         private PackageBinding computePackageFrom(char[][] constantPoolName) {
286                 if (constantPoolName.length == 1)
287                         return defaultPackage;
288
289                 PackageBinding packageBinding = getPackage0(constantPoolName[0]);
290                 if (packageBinding == null || packageBinding == TheNotFoundPackage) {
291                         packageBinding = new PackageBinding(constantPoolName[0], this);
292                         knownPackages.put(constantPoolName[0], packageBinding);
293                 }
294
295                 for (int i = 1, length = constantPoolName.length - 1; i < length; i++) {
296                         PackageBinding parent = packageBinding;
297                         if ((packageBinding = parent.getPackage0(constantPoolName[i])) == null
298                                         || packageBinding == TheNotFoundPackage) {
299                                 packageBinding = new PackageBinding(CharOperation.subarray(
300                                                 constantPoolName, 0, i + 1), parent, this);
301                                 parent.addPackage(packageBinding);
302                         }
303                 }
304                 return packageBinding;
305         }
306
307         /*
308          * Used to guarantee array type identity.
309          */
310
311         ArrayBinding createArrayType(TypeBinding type, int dimensionCount) {
312                 if (type instanceof LocalTypeBinding) // cache local type arrays with
313                                                                                                 // the local type itself
314                         return ((LocalTypeBinding) type).createArrayType(dimensionCount);
315
316                 // find the array binding cache for this dimension
317                 int dimIndex = dimensionCount - 1;
318                 int length = uniqueArrayBindings.length;
319                 ArrayBinding[] arrayBindings;
320                 if (dimIndex < length) {
321                         if ((arrayBindings = uniqueArrayBindings[dimIndex]) == null)
322                                 uniqueArrayBindings[dimIndex] = arrayBindings = new ArrayBinding[10];
323                 } else {
324                         System.arraycopy(uniqueArrayBindings, 0,
325                                         uniqueArrayBindings = new ArrayBinding[dimensionCount][],
326                                         0, length);
327                         uniqueArrayBindings[dimIndex] = arrayBindings = new ArrayBinding[10];
328                 }
329
330                 // find the cached array binding for this leaf component type (if any)
331                 int index = -1;
332                 length = arrayBindings.length;
333                 while (++index < length) {
334                         ArrayBinding currentBinding = arrayBindings[index];
335                         if (currentBinding == null) // no matching array, but space left
336                                 return arrayBindings[index] = new ArrayBinding(type,
337                                                 dimensionCount);
338                         if (currentBinding.leafComponentType == type)
339                                 return currentBinding;
340                 }
341
342                 // no matching array, no space left
343                 System.arraycopy(arrayBindings, 0,
344                                 (arrayBindings = new ArrayBinding[length * 2]), 0, length);
345                 uniqueArrayBindings[dimIndex] = arrayBindings;
346                 return arrayBindings[length] = new ArrayBinding(type, dimensionCount);
347         }
348
349         public BinaryTypeBinding createBinaryTypeFrom(IBinaryType binaryType,
350                         PackageBinding packageBinding) {
351                 return createBinaryTypeFrom(binaryType, packageBinding, true);
352         }
353
354         public BinaryTypeBinding createBinaryTypeFrom(IBinaryType binaryType,
355                         PackageBinding packageBinding, boolean needFieldsAndMethods) {
356                 BinaryTypeBinding binaryBinding = new BinaryTypeBinding(packageBinding,
357                                 binaryType, this);
358
359                 // resolve any array bindings which reference the unresolvedType
360                 ReferenceBinding cachedType = packageBinding
361                                 .getType0(binaryBinding.compoundName[binaryBinding.compoundName.length - 1]);
362                 if (cachedType != null) {
363                         if (cachedType.isBinaryBinding()) // sanity check before the
364                                                                                                 // cast... at this point the
365                                                                                                 // cache should ONLY contain
366                                                                                                 // unresolved types
367                                 return (BinaryTypeBinding) cachedType;
368
369                         UnresolvedReferenceBinding unresolvedType = (UnresolvedReferenceBinding) cachedType;
370                         unresolvedType.resolvedType = binaryBinding;
371                         updateArrayCache(unresolvedType, binaryBinding);
372                 }
373
374                 packageBinding.addType(binaryBinding);
375                 binaryBinding.cachePartsFrom(binaryType, needFieldsAndMethods);
376                 return binaryBinding;
377         }
378
379         /*
380          * Used to create packages from the package statement.
381          */
382
383         PackageBinding createPackage(char[][] compoundName) {
384                 return null;
385                 // PackageBinding packageBinding = getPackage0(compoundName[0]);
386                 // if (packageBinding == null || packageBinding == TheNotFoundPackage) {
387                 // packageBinding = new PackageBinding(compoundName[0], this);
388                 // knownPackages.put(compoundName[0], packageBinding);
389                 // }
390                 //
391                 // for (int i = 1, length = compoundName.length; i < length; i++) {
392                 // // check to see if it collides with a known type...
393                 // // this case can only happen if the package does not exist as a
394                 // directory in the file system
395                 // // otherwise when the source type was defined, the correct error
396                 // would have been reported
397                 // // unless its an unresolved type which is referenced from an
398                 // inconsistent class file
399                 // ReferenceBinding type = packageBinding.getType0(compoundName[i]);
400                 // if (type != null && type != TheNotFoundType && !(type instanceof
401                 // UnresolvedReferenceBinding))
402                 // return null;
403                 //
404                 // PackageBinding parent = packageBinding;
405                 // if ((packageBinding = parent.getPackage0(compoundName[i])) == null ||
406                 // packageBinding == TheNotFoundPackage) {
407                 // // if the package is unknown, check to see if a type exists which
408                 // would collide with the new package
409                 // // catches the case of a package statement of: package
410                 // java.lang.Object;
411                 // // since the package can be added after a set of source files have
412                 // already been compiled, we need
413                 // // whenever a package statement is encountered
414                 // if (nameEnvironment.findType(compoundName[i], parent.compoundName) !=
415                 // null)
416                 // return null;
417                 //
418                 // packageBinding = new
419                 // PackageBinding(CharOperation.subarray(compoundName, 0, i + 1),
420                 // parent, this);
421                 // parent.addPackage(packageBinding);
422                 // }
423                 // }
424                 // return packageBinding;
425         }
426
427         /*
428          * Answer the type for the compoundName if it exists in the cache. Answer
429          * theNotFoundType if it could not be resolved the first time it was looked
430          * up, otherwise answer null.
431          * 
432          * NOTE: Do not use for nested types... the answer is NOT the same for a.b.C
433          * or a.b.C.D.E assuming C is a type in both cases. In the a.b.C.D.E case,
434          * null is the answer.
435          */
436
437         public ReferenceBinding getCachedType(char[][] compoundName) {
438                 if (compoundName.length == 1) {
439                         if (defaultPackage == null)
440                                 return null;
441                         return defaultPackage.getType0(compoundName[0]);
442                 }
443
444                 PackageBinding packageBinding = getPackage0(compoundName[0]);
445                 if (packageBinding == null || packageBinding == TheNotFoundPackage)
446                         return null;
447
448                 for (int i = 1, packageLength = compoundName.length - 1; i < packageLength; i++)
449                         if ((packageBinding = packageBinding.getPackage0(compoundName[i])) == null
450                                         || packageBinding == TheNotFoundPackage)
451                                 return null;
452                 return packageBinding.getType0(compoundName[compoundName.length - 1]);
453         }
454
455         /*
456          * Answer the top level package named name if it exists in the cache. Answer
457          * theNotFoundPackage if it could not be resolved the first time it was
458          * looked up, otherwise answer null.
459          * 
460          * NOTE: Senders must convert theNotFoundPackage into a real problem package
461          * if its to returned.
462          */
463
464         PackageBinding getPackage0(char[] name) {
465                 return knownPackages.get(name);
466         }
467
468         /*
469          * Answer the top level package named name. Ask the oracle for the package
470          * if its not in the cache. Answer null if the package cannot be found.
471          */
472
473         PackageBinding getTopLevelPackage(char[] name) {
474                 PackageBinding packageBinding = getPackage0(name);
475                 if (packageBinding != null) {
476                         if (packageBinding == TheNotFoundPackage)
477                                 return null;
478                         else
479                                 return packageBinding;
480                 }
481
482                 if (nameEnvironment.isPackage(null, name)) {
483                         knownPackages.put(name, packageBinding = new PackageBinding(name,
484                                         this));
485                         return packageBinding;
486                 }
487
488                 knownPackages.put(name, TheNotFoundPackage); // saves asking the
489                                                                                                                 // oracle next time
490                 return null;
491         }
492
493         /*
494          * Answer the type corresponding to the compoundName. Ask the oracle for the
495          * type if its not in the cache. Answer null if the type cannot be found...
496          * likely a fatal error.
497          */
498
499         public ReferenceBinding getType(char[][] compoundName) {
500                 ReferenceBinding referenceBinding;
501
502                 if (compoundName.length == 1) {
503                         if (defaultPackage == null)
504                                 return null;
505
506                         if ((referenceBinding = defaultPackage.getType0(compoundName[0])) == null) {
507                                 PackageBinding packageBinding = getPackage0(compoundName[0]);
508                                 if (packageBinding != null
509                                                 && packageBinding != TheNotFoundPackage)
510                                         return null; // collides with a known package... should
511                                                                         // not call this method in such a case
512                                 referenceBinding = askForType(defaultPackage, compoundName[0]);
513                         }
514                 } else {
515                         PackageBinding packageBinding = getPackage0(compoundName[0]);
516                         if (packageBinding == TheNotFoundPackage)
517                                 return null;
518
519                         if (packageBinding != null) {
520                                 for (int i = 1, packageLength = compoundName.length - 1; i < packageLength; i++) {
521                                         if ((packageBinding = packageBinding
522                                                         .getPackage0(compoundName[i])) == null)
523                                                 break;
524                                         if (packageBinding == TheNotFoundPackage)
525                                                 return null;
526                                 }
527                         }
528
529                         if (packageBinding == null)
530                                 referenceBinding = askForType(compoundName);
531                         else if ((referenceBinding = packageBinding
532                                         .getType0(compoundName[compoundName.length - 1])) == null)
533                                 referenceBinding = askForType(packageBinding,
534                                                 compoundName[compoundName.length - 1]);
535                 }
536
537                 if (referenceBinding == null || referenceBinding == TheNotFoundType)
538                         return null;
539                 if (referenceBinding instanceof UnresolvedReferenceBinding)
540                         referenceBinding = ((UnresolvedReferenceBinding) referenceBinding)
541                                         .resolve(this);
542
543                 // compoundName refers to a nested type incorrectly (for example,
544                 // package1.A$B)
545                 if (referenceBinding.isNestedType())
546                         return new ProblemReferenceBinding(compoundName,
547                                         InternalNameProvided);
548                 else
549                         return referenceBinding;
550         }
551
552         /*
553          * Answer the type corresponding to the name from the binary file. Does not
554          * ask the oracle for the type if its not found in the cache... instead an
555          * unresolved type is returned which must be resolved before used.
556          * 
557          * NOTE: Does NOT answer base types nor array types!
558          * 
559          * NOTE: Aborts compilation if the class file cannot be found.
560          */
561
562         ReferenceBinding getTypeFromConstantPoolName(char[] signature, int start,
563                         int end) {
564                 if (end == -1)
565                         end = signature.length;
566
567                 char[][] compoundName = CharOperation.splitOn('/', signature, start,
568                                 end);
569                 ReferenceBinding binding = getCachedType(compoundName);
570                 if (binding == null) {
571                         PackageBinding packageBinding = computePackageFrom(compoundName);
572                         binding = new UnresolvedReferenceBinding(compoundName,
573                                         packageBinding);
574                         packageBinding.addType(binding);
575                 } else if (binding == TheNotFoundType) {
576                         problemReporter.isClassPathCorrect(compoundName, null);
577                         return null; // will not get here since the above error aborts
578                                                         // the compilation
579                 }
580                 return binding;
581         }
582
583         /*
584          * Answer the type corresponding to the signature from the binary file. Does
585          * not ask the oracle for the type if its not found in the cache... instead
586          * an unresolved type is returned which must be resolved before used.
587          * 
588          * NOTE: Does answer base types & array types.
589          * 
590          * NOTE: Aborts compilation if the class file cannot be found.
591          */
592
593         TypeBinding getTypeFromSignature(char[] signature, int start, int end) {
594                 int dimension = 0;
595                 while (signature[start] == '[') {
596                         start++;
597                         dimension++;
598                 }
599                 if (end == -1)
600                         end = signature.length - 1;
601
602                 // Just switch on signature[start] - the L case is the else
603                 TypeBinding binding = null;
604                 if (start == end) {
605                         switch (signature[start]) {
606                         case 'I':
607                                 binding = IntBinding;
608                                 break;
609                         case 'Z':
610                                 binding = BooleanBinding;
611                                 break;
612                         case 'V':
613                                 binding = VoidBinding;
614                                 break;
615                         case 'C':
616                                 binding = CharBinding;
617                                 break;
618                         case 'D':
619                                 binding = DoubleBinding;
620                                 break;
621                         case 'B':
622                                 binding = ByteBinding;
623                                 break;
624                         case 'F':
625                                 binding = FloatBinding;
626                                 break;
627                         case 'J':
628                                 binding = LongBinding;
629                                 break;
630                         case 'S':
631                                 binding = ShortBinding;
632                                 break;
633                         default:
634                                 throw new Error(
635                                                 Util
636                                                                 .bind(
637                                                                                 "error.undefinedBaseType", String.valueOf(signature[start]))); //$NON-NLS-1$
638                         }
639                 } else {
640                         binding = getTypeFromConstantPoolName(signature, start + 1, end);
641                 }
642
643                 if (dimension == 0)
644                         return binding;
645                 else
646                         return createArrayType(binding, dimension);
647         }
648
649         /*
650          * Ask the oracle if a package exists named name in the package named
651          * compoundName.
652          */
653
654         boolean isPackage(char[][] compoundName, char[] name) {
655                 if (compoundName == null || compoundName.length == 0)
656                         return nameEnvironment.isPackage(null, name);
657                 else
658                         return nameEnvironment.isPackage(compoundName, name);
659         }
660
661         // The method verifier is lazily initialized to guarantee the receiver, the
662         // compiler & the oracle are ready.
663
664         public MethodVerifier methodVerifier() {
665                 if (verifier == null)
666                         verifier = new MethodVerifier(this);
667                 return verifier;
668         }
669
670         public void reset() {
671                 this.defaultPackage = new PackageBinding(this); // assume the default
672                                                                                                                 // package always exists
673                 this.defaultImports = null;
674                 this.knownPackages = new HashtableOfPackage();
675
676                 this.verifier = null;
677                 for (int i = this.uniqueArrayBindings.length; --i >= 0;)
678                         this.uniqueArrayBindings[i] = null;
679                 this.uniqueArrayBindings[0] = new ArrayBinding[50]; // start off the
680                                                                                                                         // most common 1
681                                                                                                                         // dimension array @
682                                                                                                                         // 50
683
684                 for (int i = this.units.length; --i >= 0;)
685                         this.units[i] = null;
686                 this.lastUnitIndex = -1;
687                 this.lastCompletedUnitIndex = -1;
688
689                 // name environment has a longer life cycle, and must be reset in
690                 // the code which created it.
691         }
692
693         void updateArrayCache(UnresolvedReferenceBinding unresolvedType,
694                         ReferenceBinding resolvedType) {
695                 nextDimension: for (int i = 0, length = uniqueArrayBindings.length; i < length; i++) {
696                         ArrayBinding[] arrayBindings = uniqueArrayBindings[i];
697                         if (arrayBindings != null) {
698                                 for (int j = 0, max = arrayBindings.length; j < max; j++) {
699                                         ArrayBinding currentBinding = arrayBindings[j];
700                                         if (currentBinding == null)
701                                                 continue nextDimension;
702                                         if (currentBinding.leafComponentType == unresolvedType) {
703                                                 currentBinding.leafComponentType = resolvedType;
704                                                 continue nextDimension;
705                                         }
706                                 }
707                         }
708                 }
709         }
710 }