secure.phpeclipse.com Git - phpeclipse.git/blob

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