path: root/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/internal/compiler/lookup/CompilationUnitScope.java

/*******************************************************************************
 * Copyright (c) 2000, 2013 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Erling Ellingsen -  patch for bug 125570
 *******************************************************************************/
package org.eclipse.wst.jsdt.internal.compiler.lookup;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;

import org.eclipse.wst.jsdt.core.LibrarySuperType;
import org.eclipse.wst.jsdt.core.compiler.CharOperation;
import org.eclipse.wst.jsdt.core.compiler.libraries.SystemLibraryLocation;
import org.eclipse.wst.jsdt.core.infer.InferEngine;
import org.eclipse.wst.jsdt.core.infer.InferredType;
import org.eclipse.wst.jsdt.core.infer.InferrenceManager;
import org.eclipse.wst.jsdt.core.infer.InferrenceProvider;
import org.eclipse.wst.jsdt.internal.codeassist.ISearchRequestor;
import org.eclipse.wst.jsdt.internal.compiler.ASTVisitor;
import org.eclipse.wst.jsdt.internal.compiler.ast.ASTNode;
import org.eclipse.wst.jsdt.internal.compiler.ast.Assignment;
import org.eclipse.wst.jsdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.wst.jsdt.internal.compiler.ast.FunctionExpression;
import org.eclipse.wst.jsdt.internal.compiler.ast.ImportReference;
import org.eclipse.wst.jsdt.internal.compiler.ast.LocalDeclaration;
import org.eclipse.wst.jsdt.internal.compiler.ast.MethodDeclaration;
import org.eclipse.wst.jsdt.internal.compiler.ast.SingleNameReference;
import org.eclipse.wst.jsdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.wst.jsdt.internal.compiler.env.AccessRestriction;
import org.eclipse.wst.jsdt.internal.compiler.problem.ProblemReporter;
import org.eclipse.wst.jsdt.internal.compiler.util.CompoundNameVector;
import org.eclipse.wst.jsdt.internal.compiler.util.HashtableOfObject;
import org.eclipse.wst.jsdt.internal.compiler.util.HashtableOfType;
import org.eclipse.wst.jsdt.internal.compiler.util.ObjectVector;
import org.eclipse.wst.jsdt.internal.compiler.util.SimpleNameVector;
import org.eclipse.wst.jsdt.internal.compiler.util.SimpleSetOfCharArray;
import org.eclipse.wst.jsdt.internal.core.SearchableEnvironment;
import org.eclipse.wst.jsdt.internal.core.search.indexing.IIndexConstants;
import org.eclipse.wst.jsdt.internal.core.util.QualificationHelpers;
import org.eclipse.wst.jsdt.internal.core.util.Util;

public class CompilationUnitScope extends BlockScope {

	public LookupEnvironment environment;
	public CompilationUnitDeclaration referenceContext;
	public char[][] currentPackageName;
	public PackageBinding fPackage;
	public ImportBinding[] imports;
	public HashtableOfObject typeOrPackageCache; // used in Scope.getTypeOrPackage()

	public SourceTypeBinding[] topLevelTypes;
	public SourceTypeBinding[] existingTopLevelTypes;

	private CompoundNameVector qualifiedReferences;
	private SimpleNameVector simpleNameReferences;
	private ObjectVector referencedTypes;
	private ObjectVector referencedSuperTypes;

	HashtableOfType constantPoolNameUsage;
	public int analysisIndex;
	private int captureID = 1;

	/* Allows a compilation unit to inherit fields from a superType */
	public ReferenceBinding superBinding;
	
	/**
	 * <p>
	 * <code>true</code> if the {@link #superBinding} is currently being
	 * built, <code>false</code> otherwise.
	 * </p>
	 * 
	 * @see #buildSuperType()
	 * @see #fBuidingSuperBindingLock
	 */
	private volatile boolean fBuildingSuperBinding;
	
	/**
	 * <p>
	 * Lock that should be used when using the {@link #fBuildingSuperBinding}
	 * property.
	 * </p>
	 */
	private final Object fBuidingSuperBindingLock = new Object();
	
	/**
	 * boolean flag to determine if we need to build the
	 * Global Super Type for this scope.
	 */
	private boolean shouldBuildGlobalSuperType = false;
	
	private ClassScope classScope;

	public int temporaryAnalysisIndex;

	public HashSet externalCompilationUnits = new HashSet();

	public static final char FILENAME_DOT_SUBSTITUTION = '#';

	class DeclarationVisitor extends ASTVisitor {
		ArrayList methods = new ArrayList();

		public boolean visit(LocalDeclaration localDeclaration, BlockScope scope) {
			if(localDeclaration.initialization instanceof FunctionExpression) {
				this.visit(((FunctionExpression) localDeclaration.initialization).getMethodDeclaration(), scope);
			} else {
				TypeBinding type = localDeclaration.resolveVarType(scope);
				LocalVariableBinding binding = new LocalVariableBinding(localDeclaration, type, 0, false);
				localDeclaration.binding = binding;
				addLocalVariable(binding);
			}
			return false;
		}
		
		/**
		 * @see org.eclipse.wst.jsdt.internal.compiler.ASTVisitor#visit(org.eclipse.wst.jsdt.internal.compiler.ast.Assignment, org.eclipse.wst.jsdt.internal.compiler.lookup.BlockScope)
		 */
		public boolean visit(Assignment assignment, BlockScope scope) {
			/* If assigning to single name reference and there is no existing local
			 * variable binding for that reference, create one.  This is for the case
			 * where their is no variable declaration in the compilation unit but the
			 * variable is assigned to.
			 */
			if(assignment.lhs instanceof SingleNameReference) {
				SingleNameReference ref = (SingleNameReference)assignment.lhs;
				
				//only create new binding if one does not already exist
				LocalVariableBinding existingBinding = scope.compilationUnitScope().findVariable(ref.getToken());
				if(existingBinding == null) {
					LocalDeclaration localDeclaration = new LocalDeclaration(ref.getToken(),ref.sourceStart,ref.sourceEnd);
					localDeclaration.inferredType = assignment.getInferredType();
					
					TypeBinding binding = null;
					if(localDeclaration.inferredType != null) {
						binding = localDeclaration.inferredType.resolveType(scope.compilationUnitScope(), assignment);
					}
					
					LocalVariableBinding localBinding = new LocalVariableBinding(localDeclaration, binding, 0, false);
				    scope.compilationUnitScope().addLocalVariable(localBinding);
				}
			}

			return super.visit(assignment, scope);
		}

		public boolean visit(MethodDeclaration methodDeclaration, Scope parentScope) {
			// do not visit functions that are defined in another type, they will be visisted in
			// that type
			if(methodDeclaration.inferredMethod == null || methodDeclaration.inferredMethod.inType == null || methodDeclaration.inferredMethod.isConstructor) {
				char[] selector = methodDeclaration.getName();
				boolean isConstructor = false;

				if(methodDeclaration.inferredMethod != null && methodDeclaration.inferredMethod.isConstructor) {
					isConstructor = true;
				}

				MethodScope scope = new MethodScope(parentScope, methodDeclaration, false);
				if(selector != null && !methodDeclaration.hasBinding()) {
					MethodBinding methodBinding =
							scope.createMethod(methodDeclaration, selector, referenceContext.compilationUnitBinding,
									isConstructor, false);
					
					// is null if binding could not be created
					if(methodBinding != null && methodBinding.selector != null) {
						methods.add(methodBinding);
					}
					if(methodBinding.selector != null) {
						environment.defaultPackage.addBinding(methodBinding, methodBinding.selector, Binding.METHOD);
						fPackage.addBinding(methodBinding, methodBinding.selector, Binding.METHOD);
					}
					methodDeclaration.setBinding(methodBinding);
				} else {
					methodDeclaration.setScope(scope);
				}
				if(fPackage != environment.defaultPackage) {
					fPackage.addBinding(referenceContext.compilationUnitBinding, referenceContext.getMainTypeName(),
							Binding.COMPILATION_UNIT);
				}
				
				methodDeclaration.bindArguments();
			}
			return false;
		}
	}

	public CompilationUnitScope(CompilationUnitDeclaration unit, LookupEnvironment environment) {
		super(COMPILATION_UNIT_SCOPE, null);

		this.environment = environment;
		this.referenceContext = unit;
		unit.scope = this;
		
		char[][] pkgName =
				unit.currentPackage == null ? (unit.compilationResult != null ? unit.compilationResult.getPackageName()
						: null) : unit.currentPackage.tokens;
		this.currentPackageName = pkgName == null ? CharOperation.NO_CHAR_CHAR : pkgName;

		this.referencedTypes = new ObjectVector();
		if(compilerOptions().produceReferenceInfo) {
			this.qualifiedReferences = new CompoundNameVector();
			this.simpleNameReferences = new SimpleNameVector();
			this.referencedSuperTypes = new ObjectVector();
		} else {
			this.qualifiedReferences = null; // used to test if dependencies should be recorded
			this.simpleNameReferences = null;
			this.referencedSuperTypes = null;
		}

		this.fBuildingSuperBinding = false;
	}

	protected CompilationUnitScope(LookupEnvironment environment) {
		super(COMPILATION_UNIT_SCOPE, null);
		this.environment = environment;

		this.referencedTypes = new ObjectVector();
		if(compilerOptions().produceReferenceInfo) {
			this.qualifiedReferences = new CompoundNameVector();
			this.simpleNameReferences = new SimpleNameVector();
			this.referencedSuperTypes = new ObjectVector();
		} else {
			this.qualifiedReferences = null; // used to test if dependencies should be recorded
			this.simpleNameReferences = null;
			this.referencedSuperTypes = null;
		}
		
		this.fBuildingSuperBinding = false;
	}

	public ClassScope classScope() {
		if(this.classScope != null)
			return this.classScope;
		return super.classScope();
	}

	void buildFieldsAndMethods() {
		for(int i = 0, length = topLevelTypes.length; i < length; i++) {
			if(topLevelTypes[i] != null) {
				topLevelTypes[i].buildFieldsAndMethods();
			}
		}
	}

	void buildTypeBindings(AccessRestriction accessRestriction) {
		buildTypeBindings(CharOperation.NO_CHAR_CHAR, accessRestriction);
	}

	void buildTypeBindings(char[][] restrictToNames, AccessRestriction accessRestriction) {
		existingTopLevelTypes = topLevelTypes;
		topLevelTypes = new SourceTypeBinding[0]; // want it initialized if the package cannot be
													// resolved
		if(referenceContext.compilationResult.compilationUnit != null) {
			char[][] expectedPackageName = referenceContext.compilationResult.compilationUnit.getPackageName();
			if(expectedPackageName != null && !CharOperation.equals(currentPackageName, expectedPackageName)) {
				currentPackageName = expectedPackageName.length == 0 ? CharOperation.NO_CHAR_CHAR : expectedPackageName;
			}
		}
		if(currentPackageName == CharOperation.NO_CHAR_CHAR) {
			fPackage = environment.defaultPackage;
		} else {
			fPackage = environment.createPackage(currentPackageName);
		}

		this.faultInImports();

		// Skip typeDeclarations which know of previously reported errors
		int typeLength = referenceContext.numberInferredTypes;
		
		List newlyBuiltTypes = new ArrayList();

		SimpleSetOfCharArray addTypes = new SimpleSetOfCharArray(10);
		boolean shouldTraverse = true;
		String fileName = new String(this.referenceContext.getFileName());
		// do an initial pass through the types to be built and add their super types to the list, so they get
		// built in the event they are anonymous.
		for(int i = 0; i < typeLength; i++) {
			InferredType typeDecl = referenceContext.inferredTypes[i];

			if(typeDecl.isDefinition()) {
				if (restrictToNames != null && restrictToNames.length > 0) {
					boolean continueBuilding = false;
					for(int j = 0; !continueBuilding && j < restrictToNames.length; j++) {
						if(CharOperation.equals(typeDecl.getName(), restrictToNames[j]))
							continueBuilding = true;
					}
					if(continueBuilding && typeDecl.getSuperType() != null && !typeDecl.getSuperType().isIndexed()) {
						System.arraycopy(restrictToNames, 0, restrictToNames = new char[restrictToNames.length + 1][], 0, restrictToNames.length - 1);
						restrictToNames[restrictToNames.length - 1] = typeDecl.getSuperClassName();
					}
				}
			}
		}
		nextType: for(int i = 0; i < typeLength; i++) {
			InferredType typeDecl = referenceContext.inferredTypes[i];

			if(typeDecl.isDefinition()) {
				if (restrictToNames != null && restrictToNames.length > 0) {
					boolean continueBuilding = false;
					for(int j = 0; !continueBuilding && j < restrictToNames.length; j++) {
						if(CharOperation.equals(typeDecl.getName(), restrictToNames[j]))
							continueBuilding = true;
					}
					if(!continueBuilding)
						continue nextType;

				}
				ReferenceBinding typeBinding = null;
				// check that the type is not already built
				if(existingTopLevelTypes != null && restrictToNames != null && restrictToNames.length > 0) {
					for(int j = 0; j < existingTopLevelTypes.length; j++) {
						/* use #sourceName here because it does not check through all the linked types
						 * for SourceTypeBindings, which in this case we do not want to do because it is
						 * not needed and is a performance drag */
						if(existingTopLevelTypes[j] != null && CharOperation.equals(typeDecl.getName(), existingTopLevelTypes[j].sourceName())) {
							typeBinding = environment.defaultPackage.getType0(typeDecl.getName());
							if(typeBinding == null) {
								environment.defaultPackage.addType(existingTopLevelTypes[j]);
								fPackage.addType(existingTopLevelTypes[j]);
							}
							shouldTraverse = false;
							continue nextType;
						}
					}
				}
				
				shouldTraverse = false;
				
				// build the type and its synonyms
				SourceTypeBinding originalSourceType = null;
				int numberOfTypesToBuild = 1 + (referenceContext.inferredTypes[i].getSynonyms() == null ? 0 : referenceContext.inferredTypes[i].getSynonyms().length);
				for (int j = 0; j < numberOfTypesToBuild; j++) {
					if (j > 0) {
						// main type has been built, now build associated synonyms
						typeDecl = referenceContext.inferredTypes[i].getSynonyms()[j - 1];
						if(typeDecl.binding != null)
							break;
					}
					
					typeBinding = environment.defaultPackage.getType0(typeDecl.getName());
					recordSimpleReference(typeDecl.getName()); // needed to detect collision cases
					SourceTypeBinding existingBinding = null;
					if(typeBinding != null && !(typeBinding instanceof UnresolvedReferenceBinding)) {
						/* if a type exists, it must be a valid type - cannot
						 * be a NotFound problem type unless it's an unresolved
						 * type which is now being defined
						 */
						if(typeBinding instanceof SourceTypeBinding) {
							existingBinding = (SourceTypeBinding) typeBinding;
						}
					}
					ClassScope child = new ClassScope(this, typeDecl);
					SourceTypeBinding type = child.buildInferredType(null, environment.defaultPackage, accessRestriction);
					if(type != null) {
						if (j == 0) {
							originalSourceType = type;
						}
						
						if (existingBinding != null && typeDecl.isIndexed()) {
							existingBinding.addLinkedBinding(type);
							environment.defaultPackage.addType(existingBinding);
							fPackage.addType(existingBinding);
						}
						else if(typeDecl.isIndexed()) {
							addTypes.add(typeDecl.getName());
						}
						
						// set the original type as a nextType on this synonym
						if (j > 0 && originalSourceType != null) {
							type.addLinkedBinding(originalSourceType);
						}
						newlyBuiltTypes.add(type);
					}
				}
			}
		}
		
		/* shrink topLevelTypes...
		 * happens if error reported or if only building restricted type names */
		int count = newlyBuiltTypes.size();
		topLevelTypes = (SourceTypeBinding[]) newlyBuiltTypes.toArray(new SourceTypeBinding[count]);
		
		if(existingTopLevelTypes != null && restrictToNames != null && restrictToNames.length > 0) {
			System.arraycopy(topLevelTypes, 0, topLevelTypes = new SourceTypeBinding[count + existingTopLevelTypes.length], 0, count);
			System.arraycopy(existingTopLevelTypes, 0, topLevelTypes, count, existingTopLevelTypes.length);
			existingTopLevelTypes = null;
		}
		
		/* set up context, needs to be done before super type can be built
		 * since building super type may refer back to this contexts binding */
		char[] path = CharOperation.concatWith(this.currentPackageName, '/');
		if(referenceContext.compilationUnitBinding == null) {
			referenceContext.compilationUnitBinding =
					new CompilationUnitBinding(this, environment.defaultPackage, path);
			
			if(fPackage != environment.defaultPackage)
				fPackage.addBinding(referenceContext.compilationUnitBinding, referenceContext.getMainTypeName(),
						Binding.COMPILATION_UNIT);
		}
		
		// build the super type
		if(shouldBuildGlobalSuperType())
			buildSuperType();
		
		//set the super type on the binding
		this.referenceContext.compilationUnitBinding.setSuperBinding(this.superBinding);

		//add new type bindings
		char[][] typeNames = new char[addTypes.elementSize][];
		addTypes.asArray(typeNames);
		environment.addUnitsContainingBindings(typeNames, Binding.TYPE, fileName);

		// connect synonymous types, now that their synonyms should have bindings
		for (int i = 0; i < typeLength; i++) {
			char[] inferredTypeName = referenceContext.inferredTypes[i].getName();
			
			//determine if the inferredTypeName is in the restrict to list
			boolean isResctrictToName = true;
			if (restrictToNames != null && restrictToNames.length > 0) {
				isResctrictToName = false;
				for(int j = 0; !isResctrictToName && j < restrictToNames.length; j++) {
					isResctrictToName = CharOperation.equals(inferredTypeName, restrictToNames[j]);
				}
			}
			
			//if inferred type is on restricted list and any linked synonyms
			if (isResctrictToName && referenceContext.inferredTypes[i].getSynonyms() != null) {
				ReferenceBinding binding = environment.defaultPackage.getType0(inferredTypeName);
				if (binding != null && binding instanceof SourceTypeBinding) {
					for (int j = 0; j < referenceContext.inferredTypes[i].getSynonyms().length; j++) {
						ReferenceBinding synonymBinding = environment.defaultPackage.getType0(referenceContext.inferredTypes[i].getSynonyms()[j].getName());
						if (synonymBinding != null && synonymBinding instanceof SourceTypeBinding) {
							((SourceTypeBinding) binding).addLinkedBinding((SourceTypeBinding) synonymBinding);
						}
					}
				}
			}
		}
		
		if((restrictToNames == null || restrictToNames.length == 0) || shouldTraverse) {
			if(referenceContext.compilationUnitBinding.methods == Binding.NO_METHODS) {
				DeclarationVisitor visitor = new DeclarationVisitor();
				this.referenceContext.traverse(visitor, this);
				MethodBinding[] methods =
						(MethodBinding[]) visitor.methods.toArray(new MethodBinding[visitor.methods.size()]);
				referenceContext.compilationUnitBinding.setMethods(methods);
			}
		}
	}
	
	/**
	 * <p>
	 * Builds the super type for this scope. This also includes adding the
	 * "global" type to the global type type hierarchy.
	 * </p>
	 * <p>
	 * If the super type has already been built then this is a no-op.
	 * </p>
	 */
	public void buildSuperType() {
		//be sure to only build the super once and not allow an infinite loop of building to occur
		synchronized (this.fBuidingSuperBindingLock) {
			if(this.fBuildingSuperBinding || this.superBinding != null) {
				return;
			} else {
				this.fBuildingSuperBinding = true;
			}
		}
		
		try {
			char[] superTypeName = null;
			LibrarySuperType libSuperType = null;
			if(this.referenceContext.compilationResult!=null && this.referenceContext.compilationResult.compilationUnit!=null) {
				libSuperType = this.referenceContext.compilationResult.compilationUnit.getCommonSuperType();
				if(libSuperType==null) {
					return;
				} else {
					superTypeName = libSuperType.getSuperTypeName().toCharArray();
				}
			}
			
			if (superTypeName==null) {
				return;
			}
	
			this.superBinding = findType(superTypeName, environment.defaultPackage, environment.defaultPackage);
	
			if(this.superBinding==null || !this.superBinding.isValidBinding()) {
				superTypeName = null;
				return ;
			}
	
			/* If super type is combined source type, search through SourceTypes for the specific instance */
			if( (this.superBinding instanceof SourceTypeBinding)) {
				this.classScope = ((SourceTypeBinding)this.superBinding).classScope;
			} else if(this.superBinding!=null) {
				InferredType te = this.superBinding.getInferredType();
				this.classScope = new ClassScope(this, te);
			}
			
			if(this.superBinding != null && this.classScope != null) {
				SourceTypeBinding sourceType = null;
		
				if(this.superBinding instanceof SourceTypeBinding) {
					sourceType = (SourceTypeBinding)this.superBinding;
				}
				this.classScope.buildInferredType(sourceType, this.environment.defaultPackage, null);
		
				//if there is a searchable environment then merge global fields with fields on super binding
				if(this.environment().nameEnvironment instanceof SearchableEnvironment) {
					//find all of the global fields from the index
					SearchableEnvironment env = (SearchableEnvironment)this.environment().nameEnvironment;
					final HashtableOfObject globalFields = new HashtableOfObject();
					env.findVariables(null, new char[][]{IIndexConstants.GLOBAL_SYMBOL}, false, new ISearchRequestor() {
						
						public void acceptVariable(char[] signature, char[] typeQualification, char[] typeSimpleName, char[] declaringQualification, char[] declaringSimpleName, int modifiers, String path) {
							//store global field and its type name
							globalFields.put(signature, QualificationHelpers.createFullyQualifiedName(typeQualification, typeSimpleName));
						}
						
						public void acceptType(char[] packageName, char[] fileName, char[] typeName, char[][] enclosingTypeNames, int modifiers, AccessRestriction accessRestriction) {
							//ignore
						}
						
						public void acceptPackage(char[] packageName) {
							//ignore
						}
						
						public void acceptFunction(char[] signature, char[][] parameterFullyQualifedTypeNames, char[][] parameterNames, char[] returnQualification, char[] returnSimpleName, char[] declaringQualification, char[] declaringSimpleName, int modifiers, String path) {
							//ignore
						}
						
						public void acceptConstructor(int modifiers, char[] typeName, char[][] parameterTypes, char[][] parameterNames, String path, AccessRestriction access) {
							//ignore
						}
						
						public void acceptBinding(char[] packageName, char[] fileName, char[] bindingName, int bindingType, int modifiers, AccessRestriction accessRestriction) {
							//ignore
						}
					});
					
					//merge the global fields with the super binding fields
					mergeWithSuperBinding(globalFields);
				}
				
				recordTypeReference(this.superBinding);
				recordSuperTypeReference(this.superBinding);
				environment().setAccessRestriction(this.superBinding, null);
			}
			
			//check to see if the special "global" type was created in this scope, if so make it the super binding
			if(this.topLevelTypes != null) {
				TypeBinding globalType = null;
				for(int i = 0; i < this.topLevelTypes.length && globalType == null; ++i) {
					if(this.topLevelTypes[i] != null && CharOperation.equals(this.topLevelTypes[i].sourceName,IIndexConstants.GLOBAL_SYMBOL)) {
						globalType = this.topLevelTypes[i];
					}
				}
				
				if(globalType instanceof ReferenceBinding) {
					if(this.superBinding == null) {
						this.superBinding = (ReferenceBinding)globalType;
					} else if (this.superBinding instanceof SourceTypeBinding) {
						ReferenceBinding currentSuper = this.superBinding;
						ReferenceBinding previousSuper = this.superBinding;
						/* need to find the type with no super type or with Object as its super type,
						 * so that the "fake" Global object can be injected in there */
						while(currentSuper != null && !CharOperation.equals(currentSuper.sourceName, IIndexConstants.OBJECT)) {
							previousSuper = currentSuper;
							if(currentSuper instanceof SourceTypeBinding) {
								currentSuper = ((SourceTypeBinding)currentSuper).getSuperBinding0();
							}
							else {
								break;
							}
						}
						
						// if we found the null class just add the global object
						if(currentSuper == null) {
							if(!CharOperation.equals(previousSuper.sourceName, globalType.sourceName())) {
								((SourceTypeBinding)previousSuper).setSuperBinding((ReferenceBinding)globalType);
							}
						}
						else if(CharOperation.equals(currentSuper.sourceName, IIndexConstants.OBJECT)){
							// if we found the object case, set object as the parent of global first
							((SourceTypeBinding)globalType).setSuperBinding(currentSuper);
							
							if(!CharOperation.equals(previousSuper.sourceName, globalType.sourceName())) {
								((SourceTypeBinding)previousSuper).setSuperBinding((ReferenceBinding)globalType);
							}
						}
					}
				}
			}
		} finally {
			//finished building super
			synchronized (this.fBuidingSuperBindingLock) {
				this.fBuildingSuperBinding = false;
			}
		}
	}
	
	/**
	 * <p>
	 * Merges the table of global field names to their types with the fields of the super binding.
	 * </p>
	 * 
	 * @param globalFields table of global field names to their types to merge with the fields of
	 * the super binding
	 */
	private void mergeWithSuperBinding(HashtableOfObject globalFields) {
		//list of the super fields to iterate through
		List superBindingFields = new ArrayList();
		superBindingFields.addAll(Arrays.asList(this.superBinding.fields()));
		
		//set of the super field names so that duplicates do not get added to the list
		SimpleSetOfCharArray superBindingFieldsNames = new SimpleSetOfCharArray(superBindingFields.size());
		for(int i = 0; i < superBindingFields.size(); ++i) {
			superBindingFieldsNames.add(((FieldBinding)superBindingFields.get(i)).name);
		}
		
		/* for each super binding field check if there is an existing global
		 * field with the same name to merge it with */
		for(int superBindingFieldIndex = 0;
					superBindingFieldIndex < superBindingFields.size();
					++superBindingFieldIndex) {
			
			FieldBinding superBindingField = (FieldBinding)superBindingFields.get(superBindingFieldIndex);
			
			//check if there is an existing global field with the same name as the super type field
			char[] globalFieldType = (char[])globalFields.get(superBindingField.name);
			
			/* if no global field then guess that their might be an anonymous
			 * global type for the super binding.
			 * 
			 * IE:
			 * navigator.foo = 42
			 * 
			 * This creates a global anonymous type for navigator but does not
			 * add it to the global type for performance reasons. */
			if(globalFieldType == null || globalFieldType.length == 0) {
				globalFieldType = InferEngine.createAnonymousGlobalTypeName(superBindingField.name);
			}
				
			/* if the type for the global field can be found and is valid then
			 * merge it with the super binding field */
			ReferenceBinding globalFieldBinding = this.findType(globalFieldType,
						this.getCurrentPackage(), this.getCurrentPackage());
			if(globalFieldBinding != null &&
					globalFieldBinding instanceof SourceTypeBinding && 
					globalFieldBinding.isValidBinding() &&
					!globalFieldBinding.isAnyType()) {
				
				/* if the type of the super binding field is the same as the super binding
				 * then the fields of the super binding field should also be considered
				 * super binding fields
				 * 
				 * IE: there is a field on the Window type named window that has a
				 * type of Window.  Thus any fields of the window field also need to be
				 * merged with the super binding (this example is assuming window is the super
				 * type) */
				if(superBindingField.type != null && superBindingField.type.isEquivalentTo(this.superBinding)) {
					FieldBinding[] fieldsOnGlobalField = globalFieldBinding.fields();
					for(int fieldsOnGlobalFieldIndex = 0;
								fieldsOnGlobalFieldIndex < fieldsOnGlobalField.length;
								++fieldsOnGlobalFieldIndex) {
						
						//only add if field with name that is not already added
						if(!superBindingFieldsNames.includes(fieldsOnGlobalField[fieldsOnGlobalFieldIndex].name)) {
							superBindingFields.add(fieldsOnGlobalField[fieldsOnGlobalFieldIndex]);
						}
					}
				}
				
				/* if the super field type is a SourceTypeBinding then link it with that of the global field
				 * else if the super field does not have a type or is the any type set it to be the type
				 * of the global field */
				if(superBindingField.type != null && superBindingField.type instanceof SourceTypeBinding) {
					((SourceTypeBinding)superBindingField.type).addLinkedBinding((SourceTypeBinding)globalFieldBinding);
				} else if(superBindingField.type == null || superBindingField.type.isAnyType() ){
					superBindingField.type = globalFieldBinding;
				}
			}
		}
	}

	SourceTypeBinding buildType(InferredType inferredType, SourceTypeBinding enclosingType,
			PackageBinding packageBinding, AccessRestriction accessRestriction) {
		
		// provide the typeDeclaration with needed scopes
		if(enclosingType == null) {
			char[][] className = CharOperation.arrayConcat(packageBinding.compoundName, inferredType.getName());
			inferredType.binding = new SourceTypeBinding(className, packageBinding, this);

			// @GINO: Anonymous set bits
			if(!inferredType.isNamed())
				inferredType.binding.tagBits |= TagBits.AnonymousTypeMask;

		}

		SourceTypeBinding sourceType = inferredType.binding;
		environment().setAccessRestriction(sourceType, accessRestriction);
		environment().defaultPackage.addType(sourceType);
		sourceType.fPackage.addType(sourceType);
		return sourceType;
	}

	public PackageBinding getDefaultPackage() {
		return environment.defaultPackage;
	}

	public void addLocalVariable(LocalVariableBinding binding) {
		super.addLocalVariable(binding);
		environment.defaultPackage.addBinding(binding, binding.name, Binding.VARIABLE);
		fPackage.addBinding(binding, binding.name, Binding.VARIABLE);
	}

	void checkAndSetImports() {
		if(referenceContext.imports == null) {
			imports = getDefaultImports();
			return;
		}

		// allocate the import array, add java.lang.* by default
		int numberOfStatements = referenceContext.imports.length;
		int numberOfImports = numberOfStatements + 1;
		for(int i = 0; i < numberOfStatements; i++) {
			ImportReference importReference = referenceContext.imports[i];
			if(((importReference.bits & ASTNode.OnDemand) != 0)
					&& CharOperation.equals(JAVA_LANG, importReference.tokens)) {
				numberOfImports--;
				break;
			}
		}
		ImportBinding[] resolvedImports = new ImportBinding[numberOfImports];
		resolvedImports[0] = getDefaultImports()[0];
		int index = 1;

		nextImport: for(int i = 0; i < numberOfStatements; i++) {
			ImportReference importReference = referenceContext.imports[i];
			char[][] compoundName = importReference.tokens;

			// skip duplicates or imports of the current package
			for(int j = 0; j < index; j++) {
				ImportBinding resolved = resolvedImports[j];
				if(resolved.onDemand == ((importReference.bits & ASTNode.OnDemand) != 0))
					if(CharOperation.equals(compoundName, resolvedImports[j].compoundName))
						continue nextImport;
			}

			if((importReference.bits & ASTNode.OnDemand) != 0) {
				if(CharOperation.equals(compoundName, currentPackageName))
					continue nextImport;

				Binding importBinding = findImport(compoundName, compoundName.length);
				if(!importBinding.isValidBinding())
					continue nextImport; // we report all problems in faultInImports()
				resolvedImports[index++] = new ImportBinding(compoundName, true, importBinding, importReference);
			} else {
				// resolve single imports only when the last name matches
				resolvedImports[index++] = new ImportBinding(compoundName, false, null, importReference);
			}
		}

		// shrink resolvedImports... only happens if an error was reported
		if(resolvedImports.length > index)
			System.arraycopy(resolvedImports, 0, resolvedImports = new ImportBinding[index], 0, index);
		imports = resolvedImports;
	}

	/* INTERNAL USE-ONLY
	 * Innerclasses get their name computed as they are generated, since some may not
	 * be actually outputed if sitting inside unreachable code. */
	public char[] computeConstantPoolName(LocalTypeBinding localType) {
		if(localType.constantPoolName() != null) {
			return localType.constantPoolName();
		}
		// delegates to the outermost enclosing classfile, since it is the only one with a global
		// vision of its innertypes.

		if(constantPoolNameUsage == null)
			constantPoolNameUsage = new HashtableOfType();

		ReferenceBinding outerMostEnclosingType = localType.scope.outerMostClassScope().enclosingSourceType();

		// ensure there is not already such a local type name defined by the user
		int index = 0;
		char[] candidateName;
		boolean isCompliant15 = compilerOptions().complianceLevel >= ClassFileConstants.JDK1_5;
		while(true) {
			if(localType.isMemberType()) {
				if(index == 0) {
					candidateName =
							CharOperation.concat(localType.enclosingType().constantPoolName(), localType.sourceName,
									'.');
				} else {
					// in case of collision, then member name gets extra $1 inserted
					// e.g. class X { { class L{} new X(){ class L{} } } }
					candidateName =
							CharOperation.concat(localType.enclosingType().constantPoolName(), '.', String.valueOf(
									index).toCharArray(), '.', localType.sourceName);
				}
			} else if(localType.isAnonymousType()) {
				if(isCompliant15) {
					// from 1.5 on, use immediately enclosing type name
					candidateName =
							CharOperation.concat(localType.enclosingType.constantPoolName(),
									String.valueOf(index + 1).toCharArray(), '.');
				} else {
					candidateName =
							CharOperation.concat(outerMostEnclosingType.constantPoolName(),
									String.valueOf(index + 1).toCharArray(), '.');
				}
			} else {
				// local type
				if(isCompliant15) {
					candidateName =
							CharOperation.concat(CharOperation.concat(localType.enclosingType().constantPoolName(),
									String.valueOf(index + 1).toCharArray(), '.'), localType.sourceName);
				} else {
					candidateName =
							CharOperation.concat(outerMostEnclosingType.constantPoolName(), '.', String.valueOf(
									index + 1).toCharArray(), '.', localType.sourceName);
				}
			}
			if(constantPoolNameUsage.get(candidateName) != null) {
				index++;
			} else {
				constantPoolNameUsage.put(candidateName, localType);
				break;
			}
		}
		return candidateName;
	}

	void connectTypeHierarchy(char[][] typeNames) {
		if(classScope != null) {
			classScope.connectTypeHierarchy();
		}
		nextType: for(int i = 0; i < referenceContext.numberInferredTypes; i++) {
			InferredType inferredType = referenceContext.inferredTypes[i];
			if(typeNames.length > 0) {
				boolean continueBuilding = false;
				for(int j = 0; !continueBuilding && j < typeNames.length; j++) {
					if(CharOperation.equals(inferredType.getName(), typeNames[j]))
						continueBuilding = true;
				}
				if(!continueBuilding)
					continue nextType;
			}
			if(inferredType.binding != null && inferredType.binding.classScope != null) {
				inferredType.binding.classScope.connectTypeHierarchy();
			}
		}
	}

	void connectTypeHierarchy() {
		connectTypeHierarchy(CharOperation.NO_CHAR_CHAR);
	}

	void faultInImports() {
		if(this.typeOrPackageCache != null)
			return; // can be called when a field constant is resolved before static imports
		if(referenceContext.imports == null) {
			this.typeOrPackageCache = new HashtableOfObject(1);
			return;
		}

		// collect the top level type names if a single type import exists
		int numberOfStatements = referenceContext.imports.length;
		HashtableOfType typesBySimpleNames = null;
		for(int i = 0; i < numberOfStatements; i++) {
			if((referenceContext.imports[i].bits & ASTNode.OnDemand) == 0) {
				typesBySimpleNames = new HashtableOfType(topLevelTypes.length + numberOfStatements);
				for(int j = 0, length = topLevelTypes.length; j < length; j++)
					typesBySimpleNames.put(topLevelTypes[j].sourceName, topLevelTypes[j]);
				break;
			}
		}

		// allocate the import array, add java.lang.* by default
		ImportBinding[] defaultImports = getDefaultImports();
		int numberOfImports = numberOfStatements + defaultImports.length;
		for(int i = 0; i < numberOfStatements; i++) {
			ImportReference importReference = referenceContext.imports[i];
			if(((importReference.bits & ASTNode.OnDemand) != 0)
					&& CharOperation.equals(JAVA_LANG, importReference.tokens)) {
				numberOfImports--;
				break;
			}
		}
		ImportBinding[] resolvedImports = new ImportBinding[numberOfImports];
		System.arraycopy(defaultImports, 0, resolvedImports, 0, defaultImports.length);
		int index = defaultImports.length;

		// keep static imports with normal imports until there is a reason to split them up
		// on demand imports continue to be packages & types. need to check on demand type imports
		// for fields/methods
		// single imports change from being just types to types or fields
		nextImport: for(int i = 0; i < numberOfStatements; i++) {
			ImportReference importReference = referenceContext.imports[i];
			char[][] compoundName = importReference.tokens;

			// skip duplicates or imports of the current package
			for(int j = 0; j < index; j++) {
				ImportBinding resolved = resolvedImports[j];
				if(resolved.onDemand == ((importReference.bits & ASTNode.OnDemand) != 0)) {
					if(CharOperation.equals(compoundName, resolved.compoundName)) {
						continue nextImport;
					}
				}
			}
			if((importReference.bits & ASTNode.OnDemand) != 0) {
				if(CharOperation.equals(compoundName, currentPackageName)) {
					continue nextImport;
				}

				Binding importBinding = findImport(compoundName, compoundName.length);
				if(!importBinding.isValidBinding()) {
					continue nextImport;
				}
				resolvedImports[index++] = new ImportBinding(compoundName, true, importBinding, importReference);
			} else {
				Binding importBinding = findSingleImport(compoundName);
				if(!importBinding.isValidBinding()) {
					continue nextImport;
				}
				ReferenceBinding conflictingType = null;
				if(importBinding instanceof MethodBinding) {
					conflictingType = (ReferenceBinding) getType(compoundName, compoundName.length);
					if(!conflictingType.isValidBinding())
						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;
					if(importReference.isTypeUseDeprecated(referenceBinding, this))
						problemReporter().deprecatedType(referenceBinding, importReference);

					ReferenceBinding existingType = typesBySimpleNames.get(compoundName[compoundName.length - 1]);
					if(existingType != null) {
						continue nextImport;
					}
					typesBySimpleNames.put(compoundName[compoundName.length - 1], referenceBinding);
				}
				resolvedImports[index++] =
						conflictingType == null ? new ImportBinding(compoundName, false, importBinding, importReference)
								: new ImportConflictBinding(compoundName, importBinding, conflictingType,
										importReference);
			}
		}

		// shrink resolvedImports... only happens if an error was reported
		if(resolvedImports.length > index)
			System.arraycopy(resolvedImports, 0, resolvedImports = new ImportBinding[index], 0, index);
		imports = resolvedImports;

		int length = imports.length;
		this.typeOrPackageCache = new HashtableOfObject(length);
		for(int i = 0; i < length; i++) {
			ImportBinding binding = imports[i];
			if(!binding.onDemand && binding.resolvedImport instanceof ReferenceBinding
					|| binding instanceof ImportConflictBinding)
				this.typeOrPackageCache.put(binding.compoundName[binding.compoundName.length - 1], binding);
		}
	}

	public void faultInTypes() {
		faultInImports();

		this.referenceContext.compilationUnitBinding.faultInTypesForFieldsAndMethods();
		for(int i = 0, length = topLevelTypes.length; i < length; i++)
			topLevelTypes[i].faultInTypesForFieldsAndMethods();
	}

	/**
	 * this API is for code assist purpose
	 * 
	 * @param compoundName
	 * @param onDemand
	 * @return
	 */
	public Binding findImport(char[][] compoundName, boolean onDemand) {
		if(onDemand) {
			return findImport(compoundName, compoundName.length);
		} else {
			return findSingleImport(compoundName);
		}
	}

	private Binding findImport(char[][] compoundName, int length) {
		recordQualifiedReference(compoundName);

		Binding binding = environment.getTopLevelPackage(compoundName[0]);
		int i = 1;
		foundNothingOrType: if(binding != null) {
			PackageBinding packageBinding = (PackageBinding) binding;
			while(i < length) {
				int type = (i + 1 == length) ? Binding.COMPILATION_UNIT : Binding.PACKAGE;
				binding = packageBinding.getTypeOrPackage(compoundName[i++], type);
				if(binding == null || !binding.isValidBinding()) {
					binding = null;
					break foundNothingOrType;
				}
				if(i == length && (binding instanceof CompilationUnitBinding))
					return binding;
				if(!(binding instanceof PackageBinding))
					break foundNothingOrType;

				packageBinding = (PackageBinding) binding;
			}
			return packageBinding;
		}

		ReferenceBinding type;
		if(binding == null) {
			if(environment.defaultPackage == null || compilerOptions().complianceLevel >= ClassFileConstants.JDK1_4)
				return new ProblemReferenceBinding(CharOperation.subarray(compoundName, 0, i), null,
						ProblemReasons.NotFound);
			type = findType(compoundName[0], environment.defaultPackage, environment.defaultPackage);
			if(type == null || !type.isValidBinding())
				return new ProblemReferenceBinding(CharOperation.subarray(compoundName, 0, i), null,
						ProblemReasons.NotFound);
			i = 1; // reset to look for member types inside the default package type
		} else {
			type = (ReferenceBinding) binding;
		}

		while(i < length) {
			if(!type.canBeSeenBy(environment.defaultPackage))
				return new ProblemReferenceBinding(CharOperation.subarray(compoundName, 0, i), type,
						ProblemReasons.NotVisible);

			char[] name = compoundName[i++];
			// does not look for inherited member types on purpose, only immediate members
			type = type.getMemberType(name);
			if(type == null)
				return new ProblemReferenceBinding(CharOperation.subarray(compoundName, 0, i), null,
						ProblemReasons.NotFound);
		}
		if(!type.canBeSeenBy(environment.defaultPackage))
			return new ProblemReferenceBinding(compoundName, type, ProblemReasons.NotVisible);
		return type;
	}

	private Binding findSingleImport(char[][] compoundName) {
		if(compoundName.length == 1) {
			// findType records the reference
			// the name cannot be a package
			if(environment.defaultPackage == null || compilerOptions().complianceLevel >= ClassFileConstants.JDK1_4)
				return new ProblemReferenceBinding(compoundName, null, ProblemReasons.NotFound);
			ReferenceBinding typeBinding =
					findType(compoundName[0], environment.defaultPackage, environment.defaultPackage);
			if(typeBinding == null)
				return new ProblemReferenceBinding(compoundName, null, ProblemReasons.NotFound);
			return typeBinding;
		}

		return findImport(compoundName, compoundName.length);
	}

	MethodBinding findStaticMethod(ReferenceBinding currentType, char[] selector) {
		if(!currentType.canBeSeenBy(this))
			return null;

		do {
			MethodBinding[] methods = currentType.getMethods(selector);
			if(methods != Binding.NO_METHODS) {
				for(int i = methods.length; --i >= 0;) {
					MethodBinding method = methods[i];
					if(method.isStatic() && method.canBeSeenBy(environment.defaultPackage))
						return method;
				}
			}

			((SourceTypeBinding) currentType).classScope.connectTypeHierarchy();
		} while((currentType = currentType.getSuperBinding()) != null);
		return null;
	}

	ImportBinding[] getDefaultImports() {
		// initialize the default imports if necessary... share the default java.lang.* import
		Binding importBinding = environment.defaultPackage;

		// abort if java.lang cannot be found...
		if(importBinding == null || !importBinding.isValidBinding()) {
			// create a proxy for the missing BinaryType
			MissingBinaryTypeBinding missingObject =
					environment.cacheMissingBinaryType(JAVA_LANG_OBJECT, this.referenceContext);
			importBinding = missingObject.fPackage;
		}
		ImportBinding systemJSBinding = null;
		if(environment.defaultImports != null) {
			systemJSBinding = environment.defaultImports[0];
		} else {
			systemJSBinding =
					new ImportBinding(new char[][] { SystemLibraryLocation.SYSTEM_LIBARAY_NAME }, true, importBinding,
							(ImportReference) null);
			environment.defaultImports = new ImportBinding[] { systemJSBinding };
		}

		ImportBinding[] defaultImports = null;
		String[] contextIncludes = null;
		InferrenceProvider[] inferenceProviders =
				InferrenceManager.getInstance().getInferenceProviders(this.referenceContext);
		if(inferenceProviders != null && inferenceProviders.length > 0) {
			for(int i = 0; i < inferenceProviders.length; i++) {
				if(contextIncludes == null) {
					contextIncludes = inferenceProviders[i].getResolutionConfiguration().getContextIncludes();
				} else {
					String[] contextIncludesTemp =
							inferenceProviders[0].getResolutionConfiguration().getContextIncludes();
					if(contextIncludesTemp != null) {
						String[] contextIncludesOld = contextIncludes;
						contextIncludes = new String[contextIncludesTemp.length + contextIncludesOld.length];
						System.arraycopy(contextIncludesOld, 0, contextIncludes, 0, contextIncludesOld.length);
						System.arraycopy(contextIncludesTemp, 0, contextIncludes, contextIncludesOld.length - 1,
								contextIncludesTemp.length);
					}
				}
			}

		}
		if(contextIncludes != null && contextIncludes.length > 0) {
			ArrayList list = new ArrayList();
			list.add(systemJSBinding);
			for(int i = 0; i < contextIncludes.length; i++) {
				String include = contextIncludes[i];
				if(include != null) {
					int index = Util.indexOfJavaLikeExtension(include);
					if(index >= 0)
						include = include.substring(0, index);
					include = include.replace('.', FILENAME_DOT_SUBSTITUTION);
					char[][] qualifiedName = CharOperation.splitOn('/', include.toCharArray());
					Binding binding = findImport(qualifiedName, qualifiedName.length);
					if(binding.isValidBinding()) {
						list.add(new ImportBinding(qualifiedName, true, binding, null));
					}
				}
			}
			defaultImports = (ImportBinding[]) list.toArray(new ImportBinding[list.size()]);
		} else
			defaultImports = new ImportBinding[] { systemJSBinding };
		return defaultImports;
	}


	/**
	 * <p><b>NOTE:</b> NOT Public API</p>
	 * 
	 * @param compoundName
	 * @param onDemand
	 * @return
	 */
	public final Binding getImport(char[][] compoundName, boolean onDemand) {
		if(onDemand)
			return findImport(compoundName, compoundName.length);
		return findSingleImport(compoundName);
	}

	public int nextCaptureID() {
		return this.captureID++;
	}

	/**
	 * Answer the problem reporter to use for raising new problems.
	 * 
	 * Note that as a side-effect, this updates the current reference context
	 * (unit, type or method) in case the problem handler decides it is necessary
	 * to abort.
	 */
	public ProblemReporter problemReporter() {
		ProblemReporter problemReporter = referenceContext.problemReporter;
		problemReporter.referenceContext = referenceContext;
		return problemReporter;
	}

	/**
	 * What do we hold onto:
	 * 
	 * 1. when we resolve 'a.b.c', say we keep only 'a.b.c'
	 * & when we fail to resolve 'c' in 'a.b', lets keep 'a.b.c'
	 * THEN when we come across a new/changed/removed item named 'a.b.c',
	 * we would find all references to 'a.b.c'
	 * -> This approach fails because every type is resolved in every onDemand import to
	 * detect collision cases... so the references could be 10 times bigger than necessary.
	 * 
	 * 2. when we resolve 'a.b.c', lets keep 'a.b' & 'c'
	 * & when we fail to resolve 'c' in 'a.b', lets keep 'a.b' & 'c'
	 * THEN when we come across a new/changed/removed item named 'a.b.c',
	 * we would find all references to 'a.b' & 'c'
	 * -> This approach does not have a space problem but fails to handle collision cases.
	 * What happens if a type is added named 'a.b'? We would search for 'a' & 'b' but
	 * would not find a match.
	 * 
	 * 3. when we resolve 'a.b.c', lets keep 'a', 'a.b' & 'a', 'b', 'c'
	 * & when we fail to resolve 'c' in 'a.b', lets keep 'a', 'a.b' & 'a', 'b', 'c'
	 * THEN when we come across a new/changed/removed item named 'a.b.c',
	 * we would find all references to 'a.b' & 'c'
	 * OR 'a.b' -> 'a' & 'b'
	 * OR 'a' -> '' & 'a'
	 * -> As long as each single char[] is interned, we should not have a space problem
	 * and can handle collision cases.
	 * 
	 * 4. when we resolve 'a.b.c', lets keep 'a.b' & 'a', 'b', 'c'
	 * & when we fail to resolve 'c' in 'a.b', lets keep 'a.b' & 'a', 'b', 'c'
	 * THEN when we come across a new/changed/removed item named 'a.b.c',
	 * we would find all references to 'a.b' & 'c'
	 * OR 'a.b' -> 'a' & 'b' in the simple name collection
	 * OR 'a' -> 'a' in the simple name collection
	 * -> As long as each single char[] is interned, we should not have a space problem
	 * and can handle collision cases.
	 */
	void recordQualifiedReference(char[][] qualifiedName) {
		if(qualifiedReferences == null)
			return; // not recording dependencies

		int length = qualifiedName.length;
		if(length > 1) {
			while(!qualifiedReferences.contains(qualifiedName)) {
				qualifiedReferences.add(qualifiedName);
				if(length == 2) {
					recordSimpleReference(qualifiedName[0]);
					recordSimpleReference(qualifiedName[1]);
					return;
				}
				length--;
				recordSimpleReference(qualifiedName[length]);
				System.arraycopy(qualifiedName, 0, qualifiedName = new char[length][], 0, length);
			}
		} else if(length == 1) {
			recordSimpleReference(qualifiedName[0]);
		}
	}

	void recordReference(char[][] qualifiedEnclosingName, char[] simpleName) {
		recordQualifiedReference(qualifiedEnclosingName);
		recordSimpleReference(simpleName);
	}

	void recordReference(ReferenceBinding type, char[] simpleName) {
		ReferenceBinding actualType = typeToRecord(type);
		if(actualType != null)
			recordReference(actualType.compoundName, simpleName);
	}

	void recordSimpleReference(char[] simpleName) {
		if(simpleNameReferences == null)
			return; // not recording dependencies

		if(!simpleNameReferences.contains(simpleName))
			simpleNameReferences.add(simpleName);
	}

	void recordSuperTypeReference(TypeBinding type) {
		if(referencedSuperTypes == null)
			return; // not recording dependencies

		ReferenceBinding actualType = typeToRecord(type);
		if(actualType != null && !referencedSuperTypes.containsIdentical(actualType))
			referencedSuperTypes.add(actualType);
	}

	public void recordTypeConversion(TypeBinding superType, TypeBinding subType) {
		// must record the hierarchy of the subType that is converted to the superType
		recordSuperTypeReference(subType); 
	}

	void recordTypeReference(TypeBinding type) {
		if(referencedTypes == null)
			return; // not recording dependencies

		ReferenceBinding actualType = typeToRecord(type);
		if(actualType != null && !referencedTypes.containsIdentical(actualType))
			referencedTypes.add(actualType);
	}

	void recordTypeReferences(TypeBinding[] types) {
		if(referencedTypes == null)
			return; // not recording dependencies
		if(types == null || types.length == 0)
			return;

		for(int i = 0, max = types.length; i < max; i++) {
			// No need to record supertypes of method arguments & thrown exceptions, just the
			// compoundName
			// If a field/method is retrieved from such a type then a separate call does the job
			ReferenceBinding actualType = null;
			if(types[i] != null)
				actualType = typeToRecord(types[i]);
			if(actualType != null && !referencedTypes.containsIdentical(actualType))
				referencedTypes.add(actualType);
		}
	}

	Binding resolveSingleImport(ImportBinding importBinding) {
		if(importBinding.resolvedImport == null) {
			importBinding.resolvedImport = findSingleImport(importBinding.compoundName);
			if(!importBinding.resolvedImport.isValidBinding() || importBinding.resolvedImport instanceof PackageBinding) {
				if(this.imports != null) {
					ImportBinding[] newImports = new ImportBinding[imports.length - 1];
					for(int i = 0, n = 0, max = this.imports.length; i < max; i++)
						if(this.imports[i] != importBinding)
							newImports[n++] = this.imports[i];
					this.imports = newImports;
				}
				return null;
			}
		}
		return importBinding.resolvedImport;
	}

	public void storeDependencyInfo() {
		// add the type hierarchy of each referenced supertype
		// cannot do early since the hierarchy may not be fully resolved
		for(int i = 0; i < referencedSuperTypes.size; i++) { // grows as more types are added
			ReferenceBinding type = (ReferenceBinding) referencedSuperTypes.elementAt(i);
			if(!referencedTypes.containsIdentical(type))
				referencedTypes.add(type);

			if(!type.isLocalType()) {
				ReferenceBinding enclosing = type.enclosingType();
				if(enclosing != null)
					recordSuperTypeReference(enclosing);
			}
			ReferenceBinding superclass = type.getSuperBinding();
			if(superclass != null)
				recordSuperTypeReference(superclass);
		}

		for(int i = 0, l = referencedTypes.size; i < l; i++) {
			ReferenceBinding type = (ReferenceBinding) referencedTypes.elementAt(i);
			if(type instanceof MultipleTypeBinding) {
				ReferenceBinding[] types = ((MultipleTypeBinding) type).types;
				for(int j = 0; j < types.length; j++) {
					if(!types[j].isLocalType())
						recordQualifiedReference(types[j].isMemberType() ? CharOperation.splitOn('.',
								types[j].readableName()) : types[j].compoundName);

				}
			} else if(!type.isLocalType())
				recordQualifiedReference(type.isMemberType() ? CharOperation.splitOn('.', type.readableName())
						: type.compoundName);
		}

		int size = qualifiedReferences.size;
		char[][][] qualifiedRefs = new char[size][][];
		for(int i = 0; i < size; i++)
			qualifiedRefs[i] = qualifiedReferences.elementAt(i);
		referenceContext.compilationResult.qualifiedReferences = qualifiedRefs;

		size = simpleNameReferences.size;
		char[][] simpleRefs = new char[size][];
		for(int i = 0; i < size; i++)
			simpleRefs[i] = simpleNameReferences.elementAt(i);
		referenceContext.compilationResult.simpleNameReferences = simpleRefs;
	}

	public String toString() {
		return "--- JavaScriptUnit Scope : " + new String(referenceContext.getFileName()); //$NON-NLS-1$
	}

	private ReferenceBinding typeToRecord(TypeBinding type) {
		while(type.isArrayType())
			type = ((ArrayBinding) type).leafComponentType;

		switch(type.kind()) {
			case Binding.BASE_TYPE:
				return null;
		}
		if(type instanceof CompilationUnitBinding)
			return null;
		ReferenceBinding refType = (ReferenceBinding) type;
		if(refType.isLocalType())
			return null;
		return refType;
	}

	public void cleanup() {

		if(this.referencedTypes != null)
			for(int i = 0, l = referencedTypes.size; i < l; i++) {
				Object obj = referencedTypes.elementAt(i);
				if(obj instanceof SourceTypeBinding) {
					SourceTypeBinding type = (SourceTypeBinding) obj;
					type.cleanup();
				}
			}
	}

	public void addExternalVar(LocalVariableBinding binding) {
		externalCompilationUnits.add(binding.declaringScope.compilationUnitScope());
	}

	/**
	 * @return the shouldBuildGlobalSuperType
	 */
	public boolean shouldBuildGlobalSuperType() {
		return shouldBuildGlobalSuperType;
	}

	/**
	 * @param shouldBuildGlobalSuperType the shouldBuildGlobalSuperType to set
	 */
	public void setShouldBuildGlobalSuperType(boolean shouldBuild) {
		this.shouldBuildGlobalSuperType = shouldBuild;
	}
	
	
}