public int importPtr;

	private ImportBinding[] tempImports;	// to keep a record of resolved imports while traversing all in faultInImports()

private void recordImportBinding(ImportBinding bindingToAdd) {

	if (this.tempImports.length == this.importPtr) {

		System.arraycopy(this.tempImports, 0, (this.tempImports = new ImportBinding[this.importPtr + 1]), 0, this.importPtr);

	}

	this.tempImports[this.importPtr++] = bindingToAdd;

}

/**

 * Checks additional bindings (methods or types) imported from a single static import. 

 * Method is tried first, followed by type. If found, records them.

 * If in the process, import is flagged as duplicate, -1 is returned.

 * @param compoundName

 * @param typesBySimpleNames

 * @param mask

 * @param importReference

 * @return -1 when this import is flagged as duplicate, 0 otherwise.

 */

private int checkMoreStaticBindings(

		char[][] compoundName, 

		HashtableOfType typesBySimpleNames, 

		int mask,

		ImportReference importReference) {

	Binding importBinding = findSingleStaticImport(compoundName, mask);

	int temp;

	if (!importBinding.isValidBinding()) {

		// only continue of the same kind's ambiguous binding is returned

		// may have found an ambiguous type when looking for field or method. Don't continue in that case

		if (importBinding.problemId() == ProblemReasons.Ambiguous) {

			// keep it unless a duplicate can be found below

			temp = checkAndRecordImportBinding(importBinding, typesBySimpleNames, importReference, compoundName);

			if (temp == -1) return -1;

		}

	} else {

		temp = checkAndRecordImportBinding(importBinding, typesBySimpleNames, importReference, compoundName);

		if (temp == -1) return -1;

	}

	if (importBinding.kind() == Binding.METHOD) {

		// found method

		// type is left to be looked for

		// reset METHOD bit to enable lookup for only type

		mask &= ~Binding.METHOD;

		// now search for a type binding

		importBinding = findSingleStaticImport(compoundName, mask);

		if (!importBinding.isValidBinding()) {

			// only continue of the same kind's ambiguous binding is returned

			// may have found,say, an ambiguous type when looking for field or method. Don't continue in that case

			if (importBinding.problemId() == ProblemReasons.Ambiguous) {

				// keep it unless a duplicate can be found below

				temp = checkAndRecordImportBinding(importBinding, typesBySimpleNames, importReference, compoundName);

				if (temp == -1) return -1;

			}

		} else {

			temp = checkAndRecordImportBinding(importBinding, typesBySimpleNames, importReference, compoundName);

			if (temp == -1) return -1;

		}

	}

	return 0;

}

/**

 * Checks for duplicates. If all ok, records the importBinding

 * returns -1 when this import is flagged as duplicate.

 * @param importBinding

 * @param typesBySimpleNames

 * @param importReference

 * @param compoundName

 * @return -1 when this import is flagged as duplicate, importPtr otherwise.

 */

private int checkAndRecordImportBinding(

		Binding importBinding, 

		HashtableOfType typesBySimpleNames, 

		ImportReference importReference,

		char[][] compoundName) {

	ReferenceBinding conflictingType = null;

	if (importBinding instanceof MethodBinding) {

		conflictingType = (ReferenceBinding) getType(compoundName, compoundName.length);

		if (!conflictingType.isValidBinding() || (importReference.isStatic() && !conflictingType.isStatic()))

			conflictingType = null;

	}

	// collisions between an imported static field & a type should be checked according to spec... but currently not by javac

	if (importBinding instanceof ReferenceBinding || conflictingType != null) {

		ReferenceBinding referenceBinding = conflictingType == null ? (ReferenceBinding) importBinding : conflictingType;

		ReferenceBinding typeToCheck = referenceBinding.problemId() == ProblemReasons.Ambiguous

			? ((ProblemReferenceBinding) referenceBinding).closestMatch

			: referenceBinding;

		if (importReference.isTypeUseDeprecated(typeToCheck, this))

			problemReporter().deprecatedType(typeToCheck, importReference);

		ReferenceBinding existingType = typesBySimpleNames.get(compoundName[compoundName.length - 1]);

		if (existingType != null) {

			// duplicate test above should have caught this case, but make sure

			if (existingType == referenceBinding) {

				// https://bugs.eclipse.org/bugs/show_bug.cgi?id=302865

				// Check all resolved imports to see if this import qualifies as a duplicate

				for (int j = 0; j < this.importPtr; j++) {

					ImportBinding resolved = this.tempImports[j];

					if (resolved instanceof ImportConflictBinding) {

						ImportConflictBinding importConflictBinding = (ImportConflictBinding) resolved;

						if (importConflictBinding.conflictingTypeBinding == referenceBinding) {

							if (!importReference.isStatic()) {

								// resolved is implicitly static

								problemReporter().duplicateImport(importReference);

								recordImportBinding(new ImportBinding(compoundName, false, importBinding, importReference));

							}

						}

					} else if (resolved.resolvedImport == referenceBinding) {

						if (importReference.isStatic() != resolved.isStatic()) {

							problemReporter().duplicateImport(importReference);

							recordImportBinding(new ImportBinding(compoundName, false, importBinding, importReference));

						}

					}

				}

				return -1;

			}

			// either the type collides with a top level type or another imported type

			for (int j = 0, length = this.topLevelTypes.length; j < length; j++) {

				if (CharOperation.equals(this.topLevelTypes[j].sourceName, existingType.sourceName)) {

					problemReporter().conflictingImport(importReference);

					return -1;

				}

			}

			problemReporter().duplicateImport(importReference);

			return -1;

		}

		typesBySimpleNames.put(compoundName[compoundName.length - 1], referenceBinding);

	} else if (importBinding instanceof FieldBinding) {

		for (int j = 0; j < this.importPtr; j++) {

			ImportBinding resolved = this.tempImports[j];

			// find other static fields with the same name

			if (resolved.isStatic() && resolved.resolvedImport instanceof FieldBinding && importBinding != resolved.resolvedImport) {

				if (CharOperation.equals(compoundName[compoundName.length - 1], resolved.compoundName[resolved.compoundName.length - 1])) {

					problemReporter().duplicateImport(importReference);

					return -1;

				}

			}

		}

	}

	if (conflictingType == null) {

		recordImportBinding(new ImportBinding(compoundName, false, importBinding, importReference));

	} else {

		recordImportBinding(new ImportConflictBinding(compoundName, importBinding, conflictingType, importReference));

	}

	return this.importPtr;

}