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