path: root/bundles/org.eclipse.wst.jsdt.core/src/org/eclipse/wst/jsdt/core/infer/InferEngine.java

/*******************************************************************************
 * Copyright (c) 2005, 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
 *******************************************************************************/
package org.eclipse.wst.jsdt.core.infer;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

import org.eclipse.wst.jsdt.core.ast.ASTVisitor;
import org.eclipse.wst.jsdt.core.ast.IASTNode;
import org.eclipse.wst.jsdt.core.ast.IAbstractFunctionDeclaration;
import org.eclipse.wst.jsdt.core.ast.IAbstractVariableDeclaration;
import org.eclipse.wst.jsdt.core.ast.IAllocationExpression;
import org.eclipse.wst.jsdt.core.ast.IArgument;
import org.eclipse.wst.jsdt.core.ast.IAssignment;
import org.eclipse.wst.jsdt.core.ast.IBinaryExpression;
import org.eclipse.wst.jsdt.core.ast.IExpression;
import org.eclipse.wst.jsdt.core.ast.IFalseLiteral;
import org.eclipse.wst.jsdt.core.ast.IFieldReference;
import org.eclipse.wst.jsdt.core.ast.IFunctionCall;
import org.eclipse.wst.jsdt.core.ast.IFunctionDeclaration;
import org.eclipse.wst.jsdt.core.ast.IFunctionExpression;
import org.eclipse.wst.jsdt.core.ast.IJsDoc;
import org.eclipse.wst.jsdt.core.ast.ILocalDeclaration;
import org.eclipse.wst.jsdt.core.ast.INumberLiteral;
import org.eclipse.wst.jsdt.core.ast.IObjectLiteral;
import org.eclipse.wst.jsdt.core.ast.IObjectLiteralField;
import org.eclipse.wst.jsdt.core.ast.IProgramElement;
import org.eclipse.wst.jsdt.core.ast.IReference;
import org.eclipse.wst.jsdt.core.ast.IReturnStatement;
import org.eclipse.wst.jsdt.core.ast.IScriptFileDeclaration;
import org.eclipse.wst.jsdt.core.ast.ISingleNameReference;
import org.eclipse.wst.jsdt.core.ast.IStringLiteral;
import org.eclipse.wst.jsdt.core.ast.IThisReference;
import org.eclipse.wst.jsdt.core.ast.ITrueLiteral;
import org.eclipse.wst.jsdt.core.compiler.CharOperation;
import org.eclipse.wst.jsdt.internal.compiler.ast.ASTNode;
import org.eclipse.wst.jsdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.wst.jsdt.internal.compiler.ast.AllocationExpression;
import org.eclipse.wst.jsdt.internal.compiler.ast.ArrayInitializer;
import org.eclipse.wst.jsdt.internal.compiler.ast.ArrayReference;
import org.eclipse.wst.jsdt.internal.compiler.ast.Assignment;
import org.eclipse.wst.jsdt.internal.compiler.ast.BinaryExpression;
import org.eclipse.wst.jsdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.wst.jsdt.internal.compiler.ast.Expression;
import org.eclipse.wst.jsdt.internal.compiler.ast.FieldReference;
import org.eclipse.wst.jsdt.internal.compiler.ast.FunctionExpression;
import org.eclipse.wst.jsdt.internal.compiler.ast.Javadoc;
import org.eclipse.wst.jsdt.internal.compiler.ast.JavadocSingleNameReference;
import org.eclipse.wst.jsdt.internal.compiler.ast.LocalDeclaration;
import org.eclipse.wst.jsdt.internal.compiler.ast.MessageSend;
import org.eclipse.wst.jsdt.internal.compiler.ast.MethodDeclaration;
import org.eclipse.wst.jsdt.internal.compiler.ast.ObjectLiteral;
import org.eclipse.wst.jsdt.internal.compiler.ast.OperatorIds;
import org.eclipse.wst.jsdt.internal.compiler.ast.Reference;
import org.eclipse.wst.jsdt.internal.compiler.ast.SingleNameReference;
import org.eclipse.wst.jsdt.internal.compiler.ast.StringLiteral;
import org.eclipse.wst.jsdt.internal.compiler.ast.ThisReference;
import org.eclipse.wst.jsdt.internal.compiler.ast.UnaryExpression;
import org.eclipse.wst.jsdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.wst.jsdt.internal.compiler.util.HashtableOfObject;
import org.eclipse.wst.jsdt.internal.compiler.util.Util;
import org.eclipse.wst.jsdt.internal.core.search.indexing.IIndexConstants;

/**
 * The default inference engine.
 * 
 * <p>
 * Clients may subclass this class but should expect some breakage by future releases.
 * </p>
 * 
 * Provisional API: This class/interface is part of an interim API that is still under development
 * and expected to
 * change significantly before reaching stability. It is being made available at this early stage to
 * solicit feedback
 * from pioneering adopters on the understanding that any code that uses this API will almost
 * certainly be broken
 * (repeatedly) as the API evolves.
 */
public class InferEngine extends ASTVisitor implements IInferEngine {

	/**
	 * <p>
	 * String type that is initialized on first use and added to the compilation unit.
	 * </p>
	 */
	private InferredType fStringType;
	
	/**
	 * <p>
	 * Number type that is initialized on first use and added to the compilation unit.
	 * </p>
	 */
	private InferredType fNumberType;
	
	/**
	 * <p>
	 * Boolean type that is initialized on first use and added to the compilation unit.
	 * </p>
	 */
	private InferredType fBooleanType;
	
	/**
	 * <p>
	 * Function type that is initialized on first use and added to the compilation unit.
	 * </p>
	 */
	private InferredType fFunctionType;
	
	/**
	 * <p>
	 * Array type that is initialized on first use and added to the compilation unit.
	 * </p>
	 */
	private InferredType fArrayType;
	
	/**
	 * <p>
	 * Void type that is initialized on first use and added to the compilation unit.
	 * </p>
	 */
	private InferredType fVoidType;
	
	/**
	 * <p>
	 * Object type that is initialized on first use and added to the compilation unit.
	 * </p>
	 */
	private InferredType fObjectType;
	
	InferOptions inferOptions;
	CompilationUnitDeclaration compUnit;
	Context[] contexts = new Context[100];
	int contextPtr = -1;
	Context currentContext = new Context();
	protected int passNumber = 1;

	boolean isTopLevelAnonymousFunction;
	int anonymousCount = 0;
	
	public static boolean DEBUG = false;

	public InferrenceProvider inferenceProvider;

	/**
	 * @deprecated use {@link #getStringType()}
	 */
	public InferredType StringType = new InferredType(TypeConstants.JAVA_LANG_STRING[0]);
	
	/**
	 * @deprecated use {@link #getNumberType()}
	 */
	public InferredType NumberType = new InferredType(TypeConstants.NUMBER[0]);
	
	/**
	 * @deprecated use {@link #getBooleanType()}
	 */
	public InferredType BooleanType = new InferredType(TypeConstants.BOOLEAN_OBJECT[0]);
	
	/**
	 * @deprecated use {@link #getFunctionType()}
	 */
	public InferredType FunctionType = new InferredType(TypeConstants.FUNCTION[0]);
	
	/**
	 * @deprecated use {@link #getArrayType()}
	 */
	public InferredType ArrayType = new InferredType(TypeConstants.ARRAY[0]);
	
	/**
	 * @deprecated use {@link #getVoidType()}
	 */
	public InferredType VoidType = new InferredType(TypeConstants.VOID);
	
	/**
	 * @deprecated use {@link #getObjectType()}
	 */
	public InferredType ObjectType = new InferredType(TypeConstants.OBJECT);

	/**
	 * @deprecated - no longer used
	 */
	public InferredType GlobalType = new InferredType(InferredType.GLOBAL_NAME);

	public static HashtableOfObject WellKnownTypes = new HashtableOfObject();
	{
		WellKnownTypes.put(TypeConstants.OBJECT, null);
		WellKnownTypes.put(TypeConstants.ARRAY[0], null);
		WellKnownTypes.put(TypeConstants.JAVA_LANG_STRING[0], null);
		WellKnownTypes.put(TypeConstants.NUMBER[0], null);
		WellKnownTypes.put(TypeConstants.BOOLEAN_OBJECT[0], null);
		WellKnownTypes.put(TypeConstants.FUNCTION[0], null);
		WellKnownTypes.put(new char[] { 'D', 'a', 't', 'e' }, null);
		WellKnownTypes.put(new char[] { 'M', 'a', 't', 'h' }, null);
		WellKnownTypes.put(new char[] { 'R', 'e', 'g', 'E', 'x', 'p' }, null);
		WellKnownTypes.put(new char[] { 'E', 'r', 'r', 'o', 'r' }, null);
	}

	protected InferredType inferredGlobal = null;

	/**
	 * @deprecated Will be removed
	 */
	static final char[] CONSTRUCTOR_ID = { 'c', 'o', 'n', 's', 't', 'r', 'u', 'c', 't', 'o', 'r' };
	
	/**
	 * <p>
	 * Use to keep track of the current context of the infer engine.
	 * </p>
	 */
	static class Context {
		InferredType currentType;
		IFunctionDeclaration currentMethod;

		/** The current assignment. */
		IAssignment currentAssignment;

		/** the current declaration */
		ILocalDeclaration currentLocalDeclaration;
		
		/** The current return */
		IReturnStatement currentReturn;
		
		boolean isJsDocClass;

		private HashtableOfObject definedMembers;

		/* Parent context to provide chaining when searching
		 * for members in scope. */
		private Context parent = null;

		/* Root context */
		Context() {
		}

		/* Nested context */
		Context(Context parent) {
			this.parent = parent;

			currentType = parent.currentType;
			currentMethod = parent.currentMethod;
			this.currentAssignment = parent.currentAssignment;
			this.currentLocalDeclaration = parent.currentLocalDeclaration;
			this.currentReturn = parent.currentReturn;
			this.isJsDocClass = parent.isJsDocClass;
		}

		public Object getMember(char[] key) {
			Object value = null;
			if(definedMembers != null) {
				value = definedMembers.get(key);
			}

			// chain lookup
			if(value == null && parent != null) {
				value = parent.getMember(key);
			}

			return value;
		}

		public void addMember(char[] key, Object member) {
			if(key == null)
				return;

			if(definedMembers == null) {
				definedMembers = new HashtableOfObject();
			}

			definedMembers.put(key, member);
		}

		public void setCurrentType(InferredType type) {
			this.currentType = type;
			Context parentContext = this.parent;

			while(parentContext != null && parentContext.currentMethod == this.currentMethod) {
				parentContext.currentType = type;
				parentContext = parentContext.parent;
			}
		}
	}

	private static boolean REPORT_INFER_TIME = false;

	/**
	 * <p>
	 * Constructor that uses default {@link InferOptions}.
	 * </p>
	 */
	public InferEngine() {
		this(new InferOptions());
	}

	/**
	 * <p>
	 * Constructor using given {@link InferOptions}.
	 * </p>
	 * 
	 * @param inferOptions
	 *            to create this infer engine with
	 */
	public InferEngine(InferOptions inferOptions) {
		this.inferOptions = inferOptions;
	}

	public void initialize() {
		this.contextPtr = -1;
		this.currentContext = new Context();
		this.passNumber = 1;
		this.isTopLevelAnonymousFunction = false;
		this.anonymousCount = 0;
		this.inferredGlobal = null;
	}

	public void setCompilationUnit(CompilationUnitDeclaration scriptFileDeclaration) {
		this.compUnit = scriptFileDeclaration;
		buildDefinedMembers(scriptFileDeclaration.getStatements(), null);
	}

	public boolean visit(IFunctionCall functionCall) {
		boolean visitChildren = handleFunctionCall(functionCall);
		if(visitChildren) {
			if(functionCall.getReceiver() instanceof FunctionExpression) {
				if (this.contextPtr == -1) {
					this.isTopLevelAnonymousFunction = true;
				}
				if (functionCall instanceof MessageSend && ((MessageSend) functionCall).getArguments() != null) {
					MethodDeclaration methodDeclaration = ((FunctionExpression) functionCall.getReceiver()).getMethodDeclaration();
					if (methodDeclaration != null && methodDeclaration.getArguments() != null) {
						IArgument[] declaredArguments = methodDeclaration.getArguments();
						IExpression[] sentArguments = ((MessageSend) functionCall).getArguments();
						for (int i = 0; i < declaredArguments.length; i++) {
							if (i >= sentArguments.length) {
								continue;
							}
							handleFunctionDeclarationArgument(declaredArguments[i], sentArguments[i]);
						}
					}
				}
			}
		}
		return visitChildren;
	}

	protected void handleFunctionDeclarationArgument(IArgument declaredArgument, IExpression sentArgument) {
		// set the declared argument's type to be the matching parameter type
		if (!declaredArgument.isType() && declaredArgument.getInferredType() == null) {
			if (sentArgument instanceof SingleNameReference) {
				InferredType inferredType = getInferredType(sentArgument);
				if (inferredType == null) {
					char[] parameterName = getName(sentArgument);
					if (parameterName!= null && isGlobal(parameterName)) {
						inferredType = createAnonymousGlobalType(parameterName);
					}	
				}
				declaredArgument.setInferredType(inferredType);
			}
			else if (sentArgument instanceof ThisReference) {
				//check if "this" refers to the global object
				if (this.isTopLevelAnonymousFunction) {
					char[] parameterName = declaredArgument.getName();
					if (parameterName != null) {
						InferredType inferredType = createAnonymousGlobalType(parameterName);
						declaredArgument.setInferredType(inferredType);
					}	
				} 
			}
		}
	}

	public boolean visit(ILocalDeclaration localDeclaration) {
		// add as a member of the current context
		currentContext.addMember(localDeclaration.getName(), localDeclaration);

		// create a new context for the local declaration
		pushContext();
		this.currentContext.currentLocalDeclaration = localDeclaration;
		
		if(this.passNumber == 1 && localDeclaration instanceof LocalDeclaration && this.currentContext.currentMethod == null) {
			((LocalDeclaration)localDeclaration).setIsLocal(false);
		}

		if(localDeclaration.getJsDoc() != null) {
			Javadoc javadoc = (Javadoc) localDeclaration.getJsDoc();
			createTypeIfNecessary(javadoc);
			InferredAttribute attribute = null;
			if(javadoc.memberOf != null) {
				InferredType type = this.addType(javadoc.memberOf.getFullTypeName(), true);
				int nameStart = localDeclaration.sourceStart();
				attribute = type.addAttribute(localDeclaration.getName(), localDeclaration, nameStart);
				handleAttributeDeclaration(attribute, localDeclaration.getInitialization());
				if(localDeclaration.getInitialization() != null) {
					attribute.initializationStart = localDeclaration.getInitialization().sourceStart();
					attribute.type = getTypeOf(localDeclaration.getInitialization());
				}
				attribute.inType = type;
			}

			if(javadoc.returnType != null) {
				InferredType type = this.addType(changePrimitiveToObject(javadoc.returnType.getFullTypeName()));
				localDeclaration.setInferredType(type);
				if(attribute != null)
					attribute.type = type;
			}
		}

		// visit the function in case it defines a type
		if(localDeclaration.getInitialization() instanceof IFunctionExpression) {
			boolean keepVisiting = handleFunctionExpressionLocalDeclaration(localDeclaration);
			if(!keepVisiting) {
				return false;
			}
		} 
		
		//if initialization set, attempt to set the inferred type
		if(localDeclaration.getInitialization() != null) {
			if(localDeclaration.getInitialization() instanceof MessageSend) {
				handleFunctionCall((IFunctionCall) localDeclaration.getInitialization(),
						(LocalDeclaration) localDeclaration);
				if(((MessageSend)localDeclaration.getInitialization()).receiver instanceof IFunctionExpression && this.passNumber == 2) {
					if(((FunctionExpression)((MessageSend)localDeclaration.getInitialization()).receiver).methodDeclaration != null) {
						localDeclaration.setInferredType(((FunctionExpression)((MessageSend)localDeclaration.getInitialization()).receiver).methodDeclaration.inferredType);
					}
				}
			} else {
				if (this.isExpressionAType(localDeclaration.getInitialization())) {
					localDeclaration.setIsType(true);
				}
				InferredType type = this.getTypeForVariableInitialization(localDeclaration.getName(), localDeclaration.getInitialization());
				if (localDeclaration.getInferredType() == null || (type != null && type.isAnonymous))
					localDeclaration.setInferredType(type);
			}
		}
		
		return true;
	}

	/**
	 * @see org.eclipse.wst.jsdt.core.ast.ASTVisitor#endVisit(org.eclipse.wst.jsdt.core.ast.ILocalDeclaration)
	 */
	public void endVisit(ILocalDeclaration localDeclaration) {
		popContext();
	}

	private void createTypeIfNecessary(Javadoc javadoc) {
		if(javadoc.memberOf != null) {
			char[][] namespace = {};
			char[][] typeName = javadoc.memberOf.getTypeName();
			if(javadoc.namespace != null) {
				namespace = javadoc.namespace.getTypeName();
			}
			char[] name =
					CharOperation.concat(CharOperation.concatWith(namespace, '.'), CharOperation.concatWith(typeName,
							'.'), '.');
			this.currentContext.currentType = addType(name);
			if(javadoc.extendsType != null) {
				char[] superName = CharOperation.concatWith(javadoc.extendsType.getTypeName(), '.');
				this.currentContext.currentType.setSuperType(addType(superName));
			}
			this.currentContext.isJsDocClass = true;

		}

	}

	public boolean visit(IAssignment assignment) {
		//if assigning to single name add assignment to context if there is not an existing var declaration
		IAbstractVariableDeclaration existingVarDecl = null;
		IAssignment existingAssignmentDecl = null;
		if(assignment.getLeftHandSide() instanceof ISingleNameReference) {
			existingVarDecl = this.getVariable(assignment.getLeftHandSide());
			if(existingVarDecl == null) {
				existingAssignmentDecl = this.getAssignment(assignment.getLeftHandSide());
				if(existingAssignmentDecl == null) {
					currentContext.addMember(this.getName(assignment.getLeftHandSide()), assignment);
				}
			}
		}
		
		pushContext();
		this.currentContext.currentAssignment = assignment;
		
		//set the function that contains this assignment
		if(this.passNumber == 1 && assignment instanceof Assignment && this.currentContext.currentMethod != null) {
			((Assignment)assignment).setContainingFunction(this.currentContext.currentMethod);
		}
		
		IExpression assignmentExpression = assignment.getExpression();
		if(handlePotentialType(assignment)) {

		} else if(assignmentExpression instanceof FunctionExpression) {
			boolean keepVisiting = handleFunctionExpressionAssignment(assignment);
			
			//set the type on the existing var declaration if it does not already have one set
			if(assignment.getInferredType() != null && existingVarDecl != null && existingVarDecl.getInferredType() == null) {
				existingVarDecl.setInferredType(assignment.getInferredType());
			}
			
			if(!keepVisiting) {
				return false;
			}
		} else if(assignmentExpression instanceof SingleNameReference && this.currentContext.currentType != null
				&& isThis(assignment.getLeftHandSide())) {
			
			ISingleNameReference snr = (ISingleNameReference) assignmentExpression;
			Object object = this.currentContext.getMember(snr.getToken());

			IFieldReference fieldReference = (IFieldReference) assignment.getLeftHandSide();
			char[] memberName = fieldReference.getToken();
			InferredMember member = null;

			int nameStart = fieldReference.sourceEnd() - memberName.length + 1;

			/* this.foo = bar //bar is a function */
			if(object instanceof MethodDeclaration) {

				MethodDeclaration method = (MethodDeclaration) object;
				member = this.currentContext.currentType.addMethod(memberName, method, nameStart);

			}
			/* this.foo = bar //assume that bar is not a function and create a new attribute in the
			 * current type */
			else {
				member = this.currentContext.currentType.addAttribute(memberName, assignment, nameStart);
				handleAttributeDeclaration((InferredAttribute) member, assignment.getExpression());
				if(((InferredAttribute) member).type == null)
					((InferredAttribute) member).type = getTypeOf(assignmentExpression);
			}

			// setting location
			if(member != null) {
				// this is a not static member because it is being set on the this
				member.isStatic = false;
			}
		}

		// foo = ??;
		else if(assignment.getLeftHandSide() instanceof ISingleNameReference) {
			char[] variableName = this.getName(assignment);
			
			/* if there is an existing variable declaration
			 * else there is not */
			InferredType existingType = null;
			
			if(existingVarDecl != null) {
				existingType = existingVarDecl.getInferredType();
			} else if(existingAssignmentDecl != null) {
				existingType = existingAssignmentDecl.getInferredType();
			}
			
			/* if existing variable declaration does not already have an inferred type
			 * 
			 * else it does and the new assignment type is different then the currently
			 * assigned type */
			InferredType type = null;
			if(existingType == null) {
				type = this.getTypeForVariableInitialization(variableName, assignmentExpression);
				
				if(this.isExpressionAType(assignmentExpression)) {
					assignment.setIsType(true);
				}
			} else {
				InferredType newAssignmentType = this.getTypeOf(assignmentExpression);
				if(newAssignmentType != null && existingType != newAssignmentType) {
					/* if the existing type is not anonymous, not global and
					 * existing var is not an argument then create a new
					 * global anonymous type to mix everything together in
					 * 
					 * else just use the existing type */
					InferredType newCombinedType = null;
					if(!existingType.isAnonymous && !existingType.isGlobal() && !(existingVarDecl instanceof IArgument)) {
						if(existingVarDecl instanceof LocalDeclaration && ((LocalDeclaration)existingVarDecl).isLocal()) {
							newCombinedType = this.createAnonymousType(existingVarDecl, null);
						} else {
							newCombinedType = this.createAnonymousGlobalType(variableName);
						}
						newCombinedType.setIsDefinition(true);
						
						/* add the original type of the variable declaration to the new combined type
						 * 
						 * if the existing type is indexed then add it later
						 * else it is not must add it now */
						if(existingType.isIndexed()) {
							newCombinedType.addMixin(existingType.getName());
						} else {
							newCombinedType.mixin(existingType);
						}
					} else {
						newCombinedType = existingType;
					}
	
					/* add the type of the new assignment to the combined type
					 * 
					 * if the existing type is indexed then add it later
					 * else it is not must add it now */
					if(newAssignmentType.isIndexed()) {
						newCombinedType.addMixin(newAssignmentType.getName());
					} else {
						newCombinedType.mixin(newAssignmentType);
					}
					
					type = newCombinedType;
				}
			}
			
			/* use the new type to set the inferred type on this assignment and
			 * any existing variable declaration or assignment */
			if(type != null) {
				assignment.setInferredType(type);
				
				if(existingVarDecl != null) {
					existingVarDecl.setInferredType(type);
				}
				
				if(existingAssignmentDecl != null) {
					existingAssignmentDecl.setInferredType(type);
				}
			}

			return true;
		}
		else if(assignmentExpression instanceof AllocationExpression
				&& ((AllocationExpression) assignmentExpression).member instanceof FunctionExpression) {

			handleFunctionExpressionAssignment(assignment);
		} else if(assignmentExpression instanceof Assignment
				&& ((Assignment) assignmentExpression).expression instanceof FunctionExpression) {

			handleFunctionExpressionAssignment(assignment);
		}
		else if(this.inferOptions.useAssignments) {
			IExpression lhs = assignment.getLeftHandSide();
			
			// if foo.bar = ? where ? is not {} and not a function
			if(lhs instanceof FieldReference || lhs instanceof ArrayReference) {

				Reference lhsRef = (Reference) lhs;
				Expression receiver = null;
				char[] attName = null;
				int nameStart = 0;
				if(lhsRef instanceof FieldReference) {
					receiver = ((FieldReference) lhsRef).receiver;
					attName = ((FieldReference) lhsRef).token;
					nameStart = (int) (((FieldReference) lhsRef).nameSourcePosition >>> 32);
				} else if(lhsRef instanceof ArrayReference) {
					if(((ArrayReference) lhsRef).position instanceof StringLiteral) {
						receiver = ((ArrayReference) lhsRef).receiver;
						attName = ((StringLiteral) ((ArrayReference) lhsRef).position).source();
						nameStart = ((StringLiteral) ((ArrayReference) lhsRef).position).sourceStart + 1;
					}
				}

				//attempt to get receiver type
				InferredType receiverType = this.getInferredType(receiver);
				
				//if not found type yet check if receiver is function
				if(receiverType == null) {
					IFunctionDeclaration function = getDefinedFunction(receiver);
					if(function != null) {
						char[] typeName = constructTypeName(receiver);
						if(typeName != null) {
							receiverType = addType(typeName);
						}
					}
				}
				
				//all else fails on pass two will possibly create a receiver type
				if(receiverType == null && this.passNumber == 2) {
					receiverType = this.getReceiverType(receiver, true);
				}

				if(receiver != null && receiverType != null && attName != null && attName.length > 0) {
					/* if the receiver type is not anonymous and is the expression is not a type then
					 * create a new anonymous sub type to do the assignment to */
					if(!receiverType.isAnonymous && !this.isExpressionAType(receiver)) {
						receiverType = this.createTypeToAssignTo(receiver, receiverType);
						this.setTypeOf(receiver, receiverType);
					}
					
					// in the case where the supertype of the reciever is a function, make sure we store the actual function
					// for later use
					if(receiverType != null && receiverType.getSuperType() != null && receiverType.getSuperType().isFunction()) {
						IAbstractVariableDeclaration varDecl = this.getVariable(receiver);
						if(varDecl != null) {
							IExpression expression = varDecl.getInitialization();
							if(expression != null && expression instanceof IFunctionExpression) {
								receiverType.setCorrespondingFunction(((IFunctionExpression)expression).getMethodDeclaration());
							}
						}
					}
					
					/* if receiver is instance of type so create new type to assign to
					 * 
					 * else if receiver is a type then will just assign directly to it,
					 * and if not anonymous then its a static assignment that type statically */
					boolean isStatic = false;
					if(!this.isExpressionAType(receiver)) {
						receiverType = this.createTypeToAssignTo(receiver, receiverType);
					} else if(!receiverType.isAnonymous && !receiver.isThis()) {
						isStatic = true;
					}

					// check if there is an attribute or function already created
					InferredMethod method = null;
					InferredAttribute attr = receiverType.findAttribute(attName);
					if(attr == null) {
						method = receiverType.findMethod(attName, null);
					} else if (this.passNumber == 2) {
						handleAttributeDeclaration(attr);
					}

					// ignore if the attribute exists and has a type
					if((method == null && attr == null) || (method == null && attr != null && attr.type == null)) {
						//if type already set on assignment, use that
						InferredType rhsType = assignment.getInferredType();
						
						// If the RHS is a type then create a type on the LHS
						boolean isType = false;
						if(rhsType != null && assignment.getInferredType() != null && assignment.isType() &&
									this.isExpressionAType(receiver) && !receiverType.isAnonymous) {
							
							isType = true;
							
							//create new type name
							char[] newTypeName = receiverType.getName();
							newTypeName = CharOperation.concat(newTypeName, attName, '.');
							
							/* if the RHS type is anonymous just rename it to use the LHS name
							 * else create new type on the LHS and add it as a synonym of the RHS type */
							if(rhsType.isAnonymous && !rhsType.isGlobal()) {
								this.convertAnonymousTypeToNamed(rhsType, newTypeName);
								rhsType.setIsDefinition(true);
								rhsType.setNameStart(assignment.sourceStart());
							}
							else if(!CharOperation.equals(newTypeName, rhsType.getName())){
								InferredType newType = this.addType(newTypeName, true);
								rhsType.addSynonym(newType);
							}
						}
						
						//if type not found type yet, check if RHS refers to a function definition
						IFunctionDeclaration definedFunction = null;
						if(rhsType == null) {
							definedFunction = this.getDefinedFunction(assignmentExpression);
						}
						
						/* if RHS is a function, add a function to the receiver type
						 * else add new attribute to receiver type */
						if(definedFunction != null) {
							method = receiverType.addMethod(attName, definedFunction, nameStart);
							receiverType.setIsDefinition(true);
							method.isStatic = isStatic;
						} else {
							//create the attribute
							int nameStart_ = nameStart;
							attr = receiverType.addAttribute(attName, assignment, nameStart_);
							receiverType.setIsDefinition(true);
							this.handleAttributeDeclaration(attr, assignmentExpression);
							
							//if still not RHS type then get one
							if(rhsType == null) {
								/* if LHS is global "this"
								 * else just an attribute on a type */
								if(receiver instanceof IThisReference &&
											this.currentContext.currentType == this.getInferredGlobal(false)) {
									
									rhsType = this.getTypeForVariableInitialization(attName, assignmentExpression);
								} else {
									rhsType = this.getTypeOf(assignmentExpression);
									if(receiverType != null && rhsType != null && receiverType.isGlobal() && rhsType.isAnonymous) {
										char[] globalAttName = createAnonymousGlobalTypeName(attName);
										convertAnonymousTypeToNamed(rhsType, globalAttName);
									}
									// if the attribute is also a function, add the function using the corresponding function stored earlier
									if(rhsType != null && rhsType.getSuperType() != null && rhsType.getSuperType().isFunction() && rhsType.getCorrespondingFunction() != null) {
										method = receiverType.addMethod(attName, rhsType.getCorrespondingFunction(), nameStart);
										method.isStatic = isStatic;
									}
								}
							}
							
							//determine if static
							char[] possibleTypeName = constructTypeName(receiver);
							attr.isStatic = isStatic || (possibleTypeName != null && compUnit.findInferredType(possibleTypeName) != null);
							
							//assign the type to the attribute
							if(attr.type == null || rhsType != null) {
								attr.type = rhsType;
								attr.setIsType(isType);
							}
							
							//if determined RHS type set it as the inferred type for the assignment 
							if(rhsType != null) {
								assignment.setInferredType(rhsType);
							}
						}
					} else if(method == null && attr != null && attr.type != null && attr.type.getSuperType() != null && attr.type.getSuperType().isFunction() && attr.type.getCorrespondingFunction() != null) {
						// if the attribute is also a function, add the function using the cooresponding function stored earlier
						method = receiverType.addMethod(attName, attr.type.getCorrespondingFunction(), nameStart);
						receiverType.setIsDefinition(true);
						method.isStatic = isStatic;
					}
				}
			}
			// if foo = ? where ? is not {} and not a function
			else {
				// no inferred type already set, use the type of the RHS expression
				if(assignment.getInferredType() == null) {
					InferredType rhsType = this.getTypeOf(assignment.getExpression());
					assignment.setInferredType(rhsType);
				}
			}
			
			//only create global type for LHS if LHS's root is global
			if(this.isRootGlobal(lhs)) {
				// construct the LHS and RHS type names
				char[] lhsName = constructTypeName(assignment.getLeftHandSide());
				char[] rhsName = constructTypeName(assignment.getExpression());
	
				//if RHS type exists then create LHS type and add it as synonym of the RHS type
				if(lhsName != null && lhsName.length > 0 && rhsName != null && rhsName.length > 0) {
					InferredType rhsType = this.findDefinedType(rhsName);
					
					if(rhsType != null) {
						InferredType lhsType = this.addType(lhsName, true);
						lhsType.setNameStart(lhs.sourceStart());
						
						lhsType.addSynonym(rhsType);
					}
				}
			}
		}
		return true; // do nothing by default, keep traversing
	}

	protected InferredType createAnonymousType(char[] possibleTypeName, InferredType currentType) {
		char[] name;
		if(this.isKnownType(possibleTypeName)) {
			name = possibleTypeName;
		} else {
			char[] cs = String.valueOf(this.anonymousCount++).toCharArray();
			name = CharOperation.concat(ANONYMOUS_PREFIX, possibleTypeName, cs);
		}
		InferredType type = addType(name, true);
		type.isAnonymous = true;
		type.setIsGlobal(false);
		if(currentType != null) {
			type.setSuperType(currentType);
		}
		
		return type;
	}

	/**
	 * <p>
	 * Creates an anonymous type for a given node with an optional parent type.
	 * </p>
	 * 
	 * @param forNode
	 *            the node to create the anonymous type for, the text range of
	 *            this node will be used to create the anonymous type name
	 * @param parrentType
	 *            optional parent type of the new anonymous type
	 * 
	 * @return a new anonymous type
	 */
	protected InferredType createAnonymousType(IASTNode forNode, InferredType parrentType) {
		char[] name = createAnonymousTypeName(forNode);
		InferredType type = addType(name, true);
		type.isAnonymous = true;
		type.setIsGlobal(false);
		if(parrentType != null) {
			type.setSuperType(parrentType);
		}
		return type;
	}

	/**
	 * @deprecated - here for compatibility
	 */
	private InferredType createAnonymousType(IAbstractVariableDeclaration var) {

		InferredType currentType = var.getInferredType();

		if (currentType==null || !currentType.isAnonymous)
		{
			InferredType type=createAnonymousType(var, currentType);
			var.setInferredType(type);
		}
		return var.getInferredType();
	}
	
	/* Creates an anonymous type based in the location in the document. This information is used
	 * to avoid creating duplicates because of the 2-pass nature of this engine. */
	private InferredType createAnonymousType(IObjectLiteral objLit) {
		InferredType anonType = objLit.getInferredType();
		if(anonType == null) {

			char[] name = createAnonymousTypeName(objLit);
			anonType = addType(name, true);
			anonType.isAnonymous = true;
			anonType.isObjectLiteral = true;
			anonType.setSuperType(this.getObjectType());
			anonType.setIsGlobal(false);

			anonType.sourceStart = objLit.sourceStart();
			anonType.sourceEnd = objLit.sourceEnd();
		}

		populateType(anonType, objLit, false);

		return anonType;
	}

	/**
	 * <p>
	 * Creates a global anonymous type.
	 * </p>
	 * 
	 * @param varName
	 *            name of the global variable to create the global anonymous type for
	 *            
	 * @return a global anonymous type created from for the given global variable name
	 */
	protected InferredType createAnonymousGlobalType(char[] varName) {
		char[] name = createAnonymousGlobalTypeName(varName);
		InferredType globalType = this.compUnit.findInferredType(name);

		if(globalType == null) {
			globalType = this.addType(name, false);
			globalType.isAnonymous = true;
			globalType.isObjectLiteral = true;
			globalType.setSuperType(this.getObjectType());
			globalType.setIsGlobal(true);
		}

		return globalType;
	}

	/**
	 * <p>
	 * Creates an anonymous type name for the given {@link IASTNode}
	 * </p>
	 * 
	 * @param node
	 *            create the anonymous type name off the location of this node
	 * @return an anonymous type name based off the given nodes location
	 */
	protected static char[] createAnonymousTypeName(IASTNode node) {
		char[] loc = (String.valueOf(node.sourceStart()) + '_' + String.valueOf(node.sourceEnd())).toCharArray();
		return CharOperation.concat(ANONYMOUS_PREFIX, ANONYMOUS_CLASS_ID, loc);
	}

	/**
	 * <p>
	 * Creates an anonymous type name from the given variable name.
	 * </p>
	 * 
	 * @param varName
	 *            to use when creating the anonymous type name
	 * @return
	 */
	public static char[] createAnonymousGlobalTypeName(char[] varName) {
		return CharOperation.concat(CharOperation.concat(ANONYMOUS_PREFIX, ANONYMOUS_CLASS_ID), varName, '_');
	}

	/**
	 * handle the inferencing for an assignment whose right hand side is a function expression
	 * 
	 * @param the
	 *            assignment AST node
	 * @return true if handled
	 */
	protected boolean handleFunctionExpressionAssignment(IAssignment assignment) {
		IFunctionExpression functionExpression = null;
		if(assignment.getExpression() instanceof IFunctionExpression) {
			functionExpression = (IFunctionExpression) assignment.getExpression();
		} else if(assignment.getExpression() instanceof IAllocationExpression) {
			functionExpression = (IFunctionExpression) ((IAllocationExpression) assignment.getExpression()).getMember();
		} else if(assignment.getExpression() instanceof IAssignment) {
			functionExpression = (FunctionExpression) ((IAssignment) assignment.getExpression()).getExpression();
		}
		
		if (functionExpression == null) {
			return false;
		}
		
		MethodDeclaration methodDeclaration = functionExpression.getMethodDeclaration();

		char[] possibleTypeName = constructTypeName(assignment.getLeftHandSide());

		InferredType type = null;
		if(possibleTypeName != null) {
			type = compUnit.findInferredType(possibleTypeName);
			if(type == null && isPossibleClassName(possibleTypeName)) {
				type = addType(possibleTypeName, true);
			}
			if(type == null && methodDeclaration.getJsDoc() != null
					&& ((Javadoc) methodDeclaration.getJsDoc()).isConstructor) {
				type = addType(possibleTypeName, true);
				handleJSDocConstructor(type, methodDeclaration, assignment.sourceStart());
			}
		}

		// isConstructor
		if(type != null) {
			if(this.inferOptions.useInitMethod) {
				this.currentContext.currentType = type;
				int nameStart = assignment.getLeftHandSide().sourceStart();
				int expressionEnd = assignment.getExpression().sourceEnd();
				handleConstructor(type, methodDeclaration, nameStart, expressionEnd);
				
				// want to be sure to set the type of the assignment and local declaration if there is one
				assignment.setInferredType(type);
				if(this.currentContext.currentLocalDeclaration != null && CharOperation.equals(this.currentContext.currentLocalDeclaration.getName(), getName(assignment))) {
					this.currentContext.currentLocalDeclaration.setInferredType(type);
				}

				// constructor is actually an anonymous function assigned to a single name
				methodDeclaration.setIsAnonymous(true);
			}
		} else {// could be method
			if(assignment.getLeftHandSide() instanceof FieldReference
					|| assignment.getLeftHandSide() instanceof ArrayReference) {
				
				Reference ref = (Reference) assignment.getLeftHandSide();
				Expression receiver = null;
				char[] methodName = null;
				int nameStart = 0;
				if(ref instanceof FieldReference) {
					receiver = ((FieldReference) ref).receiver;
					methodName = ((FieldReference) ref).token;
					nameStart = (int) (((FieldReference) ref).nameSourcePosition >>> 32);
				} else if(ref instanceof ArrayReference) {
					if(((ArrayReference) ref).position instanceof StringLiteral) {
						receiver = ((ArrayReference) ref).receiver;
						methodName = ((StringLiteral) ((ArrayReference) ref).position).source();
						nameStart = ((StringLiteral) ((ArrayReference) ref).position).sourceStart + 1;
					}
				}
				
				//if no receiver then done
				if(receiver == null) {
					return false;
				}

				InferredType receiverType = getInferredType(receiver);
				if(receiverType == null && passNumber == 2) {
					receiverType = this.getReceiverType(receiver, true);
				}

				if(receiverType != null && methodName != null) {
					if(!receiver.isThis()) {
						receiverType = this.createTypeToAssignTo(receiver, receiverType);
					}

					// check if there is a member method already created
					InferredMethod method = receiverType.findMethod(methodName, methodDeclaration);

					if(method == null) {
						// create member method if it does not exist
						method = receiverType.addMethod(methodName, methodDeclaration, nameStart);
						receiverType.setIsDefinition(true);

						/* determine if static
						 * check if the receiver is a type */
						char[] possibleInTypeName = constructTypeName(receiver);
						method.isStatic = (possibleInTypeName != null && compUnit.findInferredType(possibleInTypeName) != null);

						return true; // keep visiting to get return type
					} else if(this.passNumber == 2) {
						return false; // no need to visit again
					}

				} else if(this.passNumber == 2 && methodName != null) { // create anonymous class
					receiverType = this.getReceiverType(receiver, false);
					if(receiverType != null) {
						InferredMethod method = receiverType.addMethod(methodName, methodDeclaration, nameStart);
						method.isStatic = !receiverType.isObjectLiteral;
						receiverType.updatePositions(assignment.sourceStart(), assignment.sourceEnd());
					}
				}
			} else if(assignment.getLeftHandSide() instanceof SingleNameReference && this.passNumber == 2) {
				// set the inferred type
				assignment.setInferredType(getTypeOf(assignment.getExpression()));

				methodDeclaration.setIsAnonymous(true);
				methodDeclaration.setSelector(((SingleNameReference) assignment.getLeftHandSide()).token);
				methodDeclaration.sourceStart = (((SingleNameReference) assignment.getLeftHandSide()).sourceStart());
			}
		}
		return true;
	}

	/**
	 * <p>
	 * Handle a local declaration who's right hand side is a function.
	 * </p>
	 * <p>
	 * Use case:
	 * </p>
	 * 
	 * <pre>
	 * foo.bar.Test = function() { this.num = 42; }
	 * </pre>
	 * 
	 * @param localDeclaration
	 *            {@link ILocalDeclaration} to attempt to infer a type from
	 * @return <code>true</code> if keep visiting, <code>false</code> otherwise.
	 */
	private boolean handleFunctionExpressionLocalDeclaration(ILocalDeclaration localDeclaration) {
		boolean keepVisiting = true;
		IFunctionExpression functionExpression = null;
		IExpression expression = localDeclaration.getInitialization();
		if(expression instanceof IFunctionExpression) {
			functionExpression = (IFunctionExpression) expression;
		} else if(expression instanceof IAllocationExpression) {
			functionExpression = (IFunctionExpression) ((IAllocationExpression) expression).getMember();
		} else if(expression instanceof IAssignment) {
			functionExpression = (FunctionExpression) ((IAssignment) expression).getExpression();
		}

		if (functionExpression == null) {
			return false;
		}
		
		MethodDeclaration methodDeclaration = functionExpression.getMethodDeclaration();
		char[] possibleTypeName = localDeclaration.getName();

		InferredType type = null;
		if(possibleTypeName != null) {
			type = compUnit.findInferredType(possibleTypeName);
			if(type == null && isPossibleClassName(possibleTypeName)) {
				type = addType(possibleTypeName, true);
			}
			if(type == null && methodDeclaration.getJsDoc() != null
					&& ((Javadoc) methodDeclaration.getJsDoc()).isConstructor) {

				type = addType(possibleTypeName, true);
				handleJSDocConstructor(type, methodDeclaration, localDeclaration.sourceStart());
			}
		}

		if(type != null) { // isConstructor
			if(this.inferOptions.useInitMethod) {
				this.currentContext.currentType = type;
				type.setIsDefinition(true);
				int nameStart = localDeclaration.sourceStart();
				type.addConstructorMethod(type.name, methodDeclaration, nameStart);
				type.updatePositions(nameStart, localDeclaration.getInitialization().sourceEnd());
				
				//set the type for the local declaration to be the new type
				localDeclaration.setInferredType(type);
				localDeclaration.setIsType(true);
			}

			keepVisiting = false;
		}
		return keepVisiting;
	}

	/**
	 * @param assignment
	 * @return whether a type was not created for this assignment
	 */
	protected boolean handlePotentialType(IAssignment assignment) {

		IExpression lhs = assignment.getLeftHandSide();
		if(lhs instanceof FieldReference) {
			FieldReference fieldReference = (FieldReference) lhs;

			/* foo.prototype = ? */
			if(fieldReference.isPrototype()) {
				/* When encountering a prototype, we are going to assume that the
				 * receiver is a type.
				 * 
				 * If the type had not been inferred, it will be added at this point */
				InferredType newType = null;
				char[] possibleTypeName = constructTypeName(fieldReference.getReceiver());
				if(possibleTypeName != null)
					newType = compUnit.findInferredType(possibleTypeName);
				else
					return true; // no type created

				// create the new type if not found
				if(newType == null) {
					// if we have the function, check if it has a return type, if so, don't consider it a new type
					IAbstractFunctionDeclaration theFunction = this.getFunction(fieldReference.getReceiver());
					IAbstractVariableDeclaration theVariable = null;
					if(theFunction == null)
						theVariable = this.getVariable(fieldReference.getReceiver());
					if(theFunction != null) {
						if(theFunction.getInferredType() != null && !theFunction.getInferredType().isVoid()) {
							return false;
						}
					} else if (theVariable != null) {
						if(theVariable.getInitialization() != null && theVariable.getInitialization() instanceof IFunctionExpression) {
							if(((IFunctionExpression)theVariable.getInitialization()).getMethodDeclaration().getInferredType() != null && 
										!((IFunctionExpression)theVariable.getInitialization()).getMethodDeclaration().getInferredType().isVoid()) {
								return false;
							}
						}
					}
					newType = addType(possibleTypeName, true);
				}
				newType.setIsDefinition(true);
				newType.updatePositions(assignment.sourceStart(), assignment.sourceEnd());

				/* foo.prototype = new ... */
				if(assignment.getExpression() instanceof IAllocationExpression) {
					// setting the super type
					IAllocationExpression allocationExpression = (IAllocationExpression) assignment.getExpression();

					InferredType superType = null;
					char[] possibleSuperTypeName = constructTypeName(allocationExpression.getMember());
					if(possibleSuperTypeName != null) {
						superType = compUnit.findInferredType(possibleSuperTypeName);

						if(superType == null)
							superType = addType(possibleSuperTypeName);

						// check if it is set already because it might be set by jsdocs
						if(newType.getSuperType() == null)
							newType.setSuperType(superType);
					}

					return true;
				}
				/* foo.prototype = {...} */
				else if(assignment.getExpression() instanceof IObjectLiteral) {
					// rather than creating an anonymous type, is better just to set the members
					// directly
					// on newType
					populateType(newType, (IObjectLiteral) assignment.getExpression(), false);

					// check if it is set already because it might be set by jsdocs
					if(newType.getSuperType() == null)
						newType.setSuperType(this.getObjectType());

					return true;
				}
				/* foo.prototype = foo.someField; */
				else if(assignment.getExpression() instanceof FieldReference) {
					InferredType superType = getTypeOf(assignment.getExpression());
					if(newType.getSuperType() == null && superType != null) {
						newType.setSuperType(superType);
					}
					return true;
				}
				/* foo.prototype = somevar; */
				else if(assignment.getExpression() instanceof SingleNameReference) {
					InferredType superType = getTypeOf(assignment.getExpression());
					if (newType.getSuperType() == null && superType != null) {
						newType.setSuperType(superType);
					}
					return true;
				}
			}
			/* foo.prototype.bar = ? */
			else if(fieldReference.receiver.isPrototype() ) {

				FieldReference prototype = (FieldReference) fieldReference.receiver;

				//if prototype receiver is a type, get its type
				InferredType assignedToType = null;
				if(this.isExpressionAType(prototype.receiver)) {
					assignedToType = this.getTypeOf(prototype.receiver);
				}
				
				//if not found assigned to type and can create possible name, then create a type
				if(assignedToType == null) {
					char[] possibleTypeName = constructTypeName(prototype.receiver);

					if(possibleTypeName != null) {
						assignedToType = addType(possibleTypeName);
						assignedToType.updatePositions(assignment.sourceStart(), assignment.sourceEnd());
						assignedToType.setIsDefinition(true);
					} else {
						return true; // can not create type, keep visiting
					}
				}

				// prevent Object literal based anonymous types from being created more than once
				if(passNumber == 1 && assignment.getExpression() instanceof IObjectLiteral) {
					return false;
				}

				char[] memberName = fieldReference.token;
				int nameStart = (int) (fieldReference.nameSourcePosition >>> 32);

				InferredType typeOf =
						(assignment.getJsDoc() != null && assignment.getJsDoc() instanceof Javadoc && ((Javadoc) assignment.getJsDoc()).returnType != null) ? this.addType(changePrimitiveToObject(((Javadoc) assignment.getJsDoc()).returnType.getFullTypeName()))
								: getTypeOf(assignment.getExpression());
				IFunctionDeclaration methodDecl = null;

				if(typeOf == null || typeOf == this.getFunctionType())
					methodDecl = getDefinedFunction(assignment.getExpression());

				if(methodDecl != null) {
					assignedToType.addMethod(memberName, methodDecl, nameStart);
				} else {
					InferredAttribute attribute = assignedToType.addAttribute(memberName, assignment, nameStart);
					handleAttributeDeclaration(attribute, assignment.getExpression());
					attribute.initializationStart = assignment.getExpression().sourceStart();
					if(attribute.type == null)
						attribute.type = typeOf;
				}
				return true;
			}
			/* this.foo = ? */
			else if(fieldReference.receiver instanceof IThisReference) {
				InferredType newType = null;

				IFunctionDeclaration parentMethod = this.currentContext.currentMethod;
				IAssignment parentAssignment = this.currentContext.parent.currentAssignment;
				ILocalDeclaration parentLocalDeclaration = this.currentContext.parent.currentLocalDeclaration;
				char[] newTypeName = null;
				int typeStart = 0;
				int typeEnd = 0;
				/* if there is a current assignment and LHS is a function and that function
				 * is the current method then use the RHS as the type name
				 * 
				 * else if there is a current local declaration and the LHS is a function and
				 * that function is the current method then use the RHS as the type name
				 * 
				 * else if the parent method is not in a type and has a name use that as the type
				 * name */
				if(this.currentContext.parent != null
						&& parentAssignment != null
						&& parentAssignment.getExpression() instanceof IFunctionExpression
						&& ((IFunctionExpression) parentAssignment.getExpression()).getMethodDeclaration() == parentMethod) {
					// see if we're adding a field through the prototype
					if (parentAssignment.getLeftHandSide().getASTType() == IASTNode.FIELD_REFERENCE
						&& ((Expression) ((IFieldReference) parentAssignment.getLeftHandSide()).getReceiver()).isPrototype()) {
						newTypeName = Util.getTypeName(((IFieldReference) ((IFieldReference) parentAssignment.getLeftHandSide()).getReceiver()).getReceiver());
					}
					else {
						newTypeName = Util.getTypeName(parentAssignment.getLeftHandSide());
					}
					typeStart = parentAssignment.sourceStart();
					typeEnd = parentAssignment.sourceEnd();
				} else if(this.currentContext.parent != null
						&& parentLocalDeclaration != null
						&& parentLocalDeclaration.getInitialization() instanceof IFunctionExpression
						&& ((IFunctionExpression) parentLocalDeclaration.getInitialization()).getMethodDeclaration() == parentMethod) {

					newTypeName = parentLocalDeclaration.getName();
					typeStart = parentLocalDeclaration.sourceStart();
					typeEnd = parentLocalDeclaration.sourceEnd();
				} else if(parentMethod != null
						&& parentMethod.getName() != null
						&& (parentMethod.getInferredMethod() == null || parentMethod.getInferredMethod().inType == null)) {

					newTypeName = parentMethod.getName();
					typeStart = parentMethod.sourceStart();
					typeEnd = parentMethod.sourceEnd();
				}

				// if calculated new type name, use it to create a new type
				if(newTypeName != null) {
					newType = compUnit.findInferredType(newTypeName);
					// create the new type if not found
					if(newType == null) {
						newType = addType(newTypeName);
					}
				} else {
					return false; // no type to create
				}

				newType.setIsDefinition(true);
				newType.updatePositions(typeStart, typeEnd);
				
				//if there is a parent assignment then set the inferred type and that it is a type
				if(parentAssignment != null) {
					parentAssignment.setInferredType(newType);
					parentAssignment.setIsType(true);
				}
				
				//if there is a parent declaration then set the inferred type and that it is a type
				if(parentLocalDeclaration != null) {
					parentLocalDeclaration.setInferredType(newType);
					parentLocalDeclaration.setIsType(true);
				}

				// prevent Object literal based anonymous types from being created more than once
				if(passNumber == 1 && assignment.getExpression() instanceof IObjectLiteral) {
					return false;
				}

				char[] memberName = fieldReference.token;
				int nameStart = (int) (fieldReference.nameSourcePosition >>> 32);

				InferredType typeOf = getTypeOf(assignment.getExpression());
				IFunctionDeclaration methodDecl = null;

				if(typeOf == null || typeOf == this.getFunctionType()) {
					methodDecl = getDefinedFunction(assignment.getExpression());
				}

				if(methodDecl != null) {
					newType.addMethod(memberName, methodDecl, nameStart);
					if(methodDecl.getInferredType() == null && assignment.getJsDoc() != null
							&& ((Javadoc) assignment.getJsDoc()).returnType != null) {
						if(((Javadoc) assignment.getJsDoc()).returnType.getFullTypeName() != null)
							methodDecl.setInferredType(addType(((Javadoc) assignment.getJsDoc()).returnType.getFullTypeName()));
					}
				} else {
					InferredAttribute attribute = newType.addAttribute(memberName, assignment, nameStart);
					if(attribute.type == null && assignment.getJsDoc() != null
							&& ((Javadoc) assignment.getJsDoc()).returnType != null) {
						if(((Javadoc) assignment.getJsDoc()).returnType.getFullTypeName() != null)
							attribute.type = addType(((Javadoc) assignment.getJsDoc()).returnType.getFullTypeName());
					}
					handleAttributeDeclaration(attribute, assignment.getExpression());
					attribute.initializationStart = assignment.getExpression().sourceStart();
					if(attribute.type == null)
						attribute.type = typeOf;
				}
				return true;
			}			
		}
		return false;
	}

	/**
	 * Get the function referenced by the expression
	 * 
	 * @param expression
	 *            AST node
	 * @return the function or null
	 */
	protected IFunctionDeclaration getDefinedFunction(IExpression expression) {
		if(expression instanceof SingleNameReference) {
			Object object = this.currentContext.getMember(((SingleNameReference) expression).token);
			if(object instanceof AbstractMethodDeclaration) {
				return (MethodDeclaration) object;
			}
		} else if(expression instanceof FunctionExpression) {
			return ((FunctionExpression) expression).methodDeclaration;
		} else if(expression instanceof FieldReference) {
			FieldReference fieldReference = (FieldReference) expression;
			InferredType receiverType = getInferredType(fieldReference.receiver);
			if(receiverType == null && passNumber == 2) {
				receiverType = this.getReceiverType(fieldReference.receiver, false);
			}
			if(receiverType != null) {
				InferredMethod method = receiverType.findMethod(fieldReference.token, null);
				if(method != null) {
					return method.getFunctionDeclaration();
				}
			}

		}

		return null;

	}

	/**
	 * <p>
	 * Sets the inferred type of the given expression to the given type. Any existing inferred type
	 * is overridden. If the given expression is not supported by this method then it is a no op.
	 * </p>
	 * 
	 * <p>
	 * Currently supports:
	 * <ul>
	 * <li>{@link ISingleNameReference}</li>
	 * <li>{@link FieldReference} - if it can resolve everything it needs to</li>
	 * <li>{@link IObjectLiteral}</li>
	 * <li>{@link IThisReference}</li>
	 * </ul>
	 * </p>
	 * 
	 * @param expression
	 *            to set the inferred type for
	 * @param type
	 *            inferred type to set on the given expression
	 */
	protected void setTypeOf(IExpression expression, InferredType type) {
		if(expression instanceof ISingleNameReference) {
			//set on variable declaration if there is one
			IAbstractVariableDeclaration varDecl = getVariable(expression);
			if(varDecl != null) {
				varDecl.setInferredType(type);
			}

			//set on global field if there is one
			if(this.inferredGlobal != null) {
				InferredAttribute attribute =
						this.inferredGlobal.findAttribute(((ISingleNameReference) expression).getToken());
				if(attribute != null) {
					attribute.type = type;
				}
			}
			
			//set on assignment if there is one
			IAssignment varAssignment = this.getAssignment(expression);
			if(varAssignment != null) {
				varAssignment.setInferredType(type);
			}
		} else if(expression instanceof FieldReference) {
			FieldReference fieldReference = (FieldReference) expression;
			InferredType parentType = this.getTypeOf(fieldReference.getReceiver());
			if(parentType != null) {
				InferredAttribute attr = parentType.findAttribute(fieldReference.token);
				if(attr != null) {
					attr.type = type;
				}
			}
		} else if(expression instanceof IObjectLiteral) {
			((IObjectLiteral) expression).setInferredType(type);
		} else if(expression instanceof IThisReference) {
			this.currentContext.currentType = type;
		}
	}

	protected InferredType getTypeOf(IExpression expression) {
		if(expression instanceof IStringLiteral) {
			return this.getStringType();
		} else if(expression instanceof INumberLiteral) {
			return this.getNumberType();
		} else if(expression instanceof IAllocationExpression) {
			IAllocationExpression allocationExpression = (IAllocationExpression) expression;
			IExpression member = allocationExpression.getMember();
			InferredType type = null;
			
			//check for type with the same name as the allocation member
			char[] possibleTypeName = constructTypeName(member);
			if(possibleTypeName != null) {
				type = compUnit.findInferredType(possibleTypeName);

			}
			
			/* if no existing type with the same name as the allocation member
			 * attempt to get the type of the member */
			if(type == null) {
				type = this.getTypeOf(member);
			}
			
			/* if no type with same name as member, and member does not have a type,
			 * create a new type with the same name as the member */
			if((type == null || type == getFunctionType()) && possibleTypeName != null && possibleTypeName.length > 0) {
				type = this.addType(possibleTypeName, false);
			}
			
			return type;
		} else if(expression instanceof ISingleNameReference) {
			//check for variable declaration to get type from
			IAbstractVariableDeclaration varDecl = this.getVariable(expression);
			if(varDecl != null) {
				return varDecl.getInferredType();
			}
			
			//check global type to get type from
			if(this.inferredGlobal != null) {
				InferredAttribute attribute =
						this.inferredGlobal.findAttribute(((ISingleNameReference) expression).getToken());
				if(attribute != null) {
					return attribute.type;
				}
			}
			
			//check for an assignment to get the type from
			IAssignment assign = this.getAssignment(expression);
			if(assign != null) {
				InferredType type = assign.getInferredType();
				if(type != null) {
					return type;
				}
			}
			
			/* check if expression is a function and if there is a type with the same name,
			 * if so then the given expression is a reference to that type */
			IAbstractFunctionDeclaration funcDecl = this.getFunction(expression);
			if(funcDecl != null) {
				InferredType type = this.findDefinedType(funcDecl.getName());
				if(type != null) {
					return type;
				}
			}
			
			//search for type with that name
			char[] possibleTypeName = this.constructTypeName(expression);
			if(possibleTypeName != null) {
				InferredType type = compUnit.findInferredType(possibleTypeName);
				if(type != null) {
					return type;
				}
			}
			
			//search for anonymous global type based of SNR
			char[] possibleGlobalTypeName = createAnonymousGlobalTypeName(((SingleNameReference)expression).token);
			if(possibleGlobalTypeName != null) {
				InferredType type = compUnit.findInferredType(possibleGlobalTypeName);
				if(type != null) {
					return type;
				}
			}
			if(funcDecl != null) {
				return getFunctionType();
			}
		} else if(expression instanceof FieldReference) {
			FieldReference fieldReference = (FieldReference) expression;
			/* if this reference and in current type
			 * else not  */
			if(fieldReference.receiver.isThis() && currentContext.currentType != null) {
				InferredAttribute attribute = currentContext.currentType.findAttribute(fieldReference.getToken());
				if(attribute != null) {
					return attribute.type;
				}
			} else {
				//get the receiver type then get the type of an existing field or function
				InferredType recieverType = this.getReceiverType(((FieldReference) expression).getReceiver(), false);
				if(recieverType != null) {
					char[] fieldName = ((FieldReference) expression).getToken();
					InferredAttribute attr = recieverType.findAttribute(fieldName);
					if(attr != null) {
						return attr.type;
					} else if(recieverType.findMethod(fieldName, null) != null){
						return this.getFunctionType();
					}
				}
			}
			
			char[] typeName = constructTypeName(expression);
			if(typeName != null && typeName.length > 0) {
				InferredType type = this.findDefinedType(typeName);
				if(type != null) {
					return type;
				}
			}
		} else if(expression instanceof IReturnStatement) {
			return ((IReturnStatement) expression).getInferredType();
		} else if(expression instanceof ArrayInitializer) {
			ArrayInitializer arrayInitializer = (ArrayInitializer) expression;
			boolean typeSet = false;
			InferredType memberType = null;
			if(arrayInitializer.expressions != null)
				for(int i = 0; i < arrayInitializer.expressions.length; i++) {
					InferredType thisType = getTypeOf(arrayInitializer.expressions[i]);
					if(thisType != null) {
						if(!thisType.equals(memberType))
							if(!typeSet) {
								memberType = thisType;
							} else {
								memberType = null;
							}
						typeSet = true;

					}
				}
			if(memberType != null) {
				InferredType type = new InferredType(InferredType.ARRAY_NAME);
				type.referenceClass = memberType;
				return type;
			} else {
				return this.getArrayType();
			}
		} else if(expression instanceof ITrueLiteral || expression instanceof IFalseLiteral) {
			return this.getBooleanType();
		} else if(expression instanceof IObjectLiteral) {

			// create an anonymous type based on the ObjectLiteral
			InferredType type = createAnonymousType((IObjectLiteral) expression);

			// set the start and end
			type.sourceStart = expression.sourceStart();
			type.sourceEnd = expression.sourceEnd();

			return type;
		} else if(expression instanceof IThisReference) {
			return this.currentContext.currentType != null ? this.currentContext.currentType : getInferredGlobal(true);
		} else if(expression instanceof Assignment)
			return getTypeOf(((Assignment) expression).getExpression());
		else if(expression instanceof FunctionExpression)
			return this.getFunctionType();
		else if(expression instanceof UnaryExpression) {
			return getTypeOf(((UnaryExpression) expression).expression);
		} else if(expression instanceof BinaryExpression) {
			BinaryExpression bExpression = (BinaryExpression) expression;
			int operator = (bExpression.bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT;
			switch(operator) {
				case OperatorIds.MULTIPLY:
				case OperatorIds.DIVIDE:
				case OperatorIds.REMAINDER:
				case OperatorIds.MINUS:
				case OperatorIds.LEFT_SHIFT:
				case OperatorIds.RIGHT_SHIFT:
					return this.getNumberType();
				case OperatorIds.PLUS: {
					InferredType leftType = getTypeOf(bExpression.left);
					InferredType rightType = getTypeOf(bExpression.right);
					if(leftType != null && leftType.equals(this.getStringType())) {
						return this.getStringType();
					}
					if(rightType != null && rightType.equals(this.getStringType())) {
						return this.getStringType();
					}
					if(leftType == null || rightType == null) {
						return null;
					}
					if(leftType.equals(this.getStringType()) || rightType.equals(this.getStringType())) {
						return this.getStringType();
					} else if(leftType.equals(this.getNumberType()) && rightType.equals(this.getNumberType())) {
						return this.getNumberType();
					}
					return null;
				}
				case OperatorIds.AND_AND:
				case OperatorIds.OR_OR: {
					/* if the case:
					 * 		foo = foo || ""
					 * 		return foo || ""
					 * 		foo = foo && ""
					 * 		return foo || ""
					 * else a normal || binary case */
					if((this.currentContext.currentAssignment != null && expressionContains(this.currentContext.currentAssignment.getExpression(), bExpression)) ||
								(this.currentContext.currentLocalDeclaration != null && expressionContains(this.currentContext.currentLocalDeclaration.getInitialization(), bExpression)) ||
								(this.currentContext.currentReturn != null && expressionContains(this.currentContext.currentReturn.getExpression(), bExpression))) {

						InferredType leftType = this.getTypeOf(bExpression.left);
						InferredType rightType = this.getTypeOf(bExpression.right);

						/* if both the left and right type are the same then just return the left one
						 * else merge the two types into one type
						 */
						if(leftType == rightType) {
							return leftType;
						} else if(leftType != null && rightType != null) {
							InferredType newCombinedType  = this.createAnonymousType(expression, null);
							
							/* add the left type to the combined type
							 * 
							 * if the left type is indexed then add it later
							 * else it is not must add it now */
							if(leftType.isIndexed()) {
								newCombinedType.addMixin(leftType.getName());
							} else {
								newCombinedType.mixin(leftType);
							}
							
							/* add the right type to the combined type
							 * 
							 * if the right type is indexed then add it later
							 * else it is not must add it now */
							if(rightType.isIndexed()) {
								newCombinedType.addMixin(rightType.getName());
							} else {
								newCombinedType.mixin(rightType);
							}
							
							return newCombinedType;
						} else if(leftType != null) {
							return leftType;
						} else if(rightType != null) {
							return rightType;
						}
					}
					
					return this.getBooleanType();
				}
				case OperatorIds.EQUAL_EQUAL:
				case OperatorIds.EQUAL_EQUAL_EQUAL:
				case OperatorIds.NOT_EQUAL:
				case OperatorIds.NOT_EQUAL_EQUAL:
				case OperatorIds.GREATER:
				case OperatorIds.GREATER_EQUAL:
				case OperatorIds.LESS:
				case OperatorIds.LESS_EQUAL:
				case OperatorIds.INSTANCEOF:
				case OperatorIds.IN:
					return this.getBooleanType();
				default:
					return null;
			}
		} else if(expression instanceof MessageSend) {
			if(((MessageSend)expression).receiver instanceof IFunctionExpression) {
				if(((FunctionExpression)((MessageSend)expression).receiver).methodDeclaration != null) {
					return ((FunctionExpression)((MessageSend)expression).receiver).methodDeclaration.inferredType;
				}
			} else if(((MessageSend)expression).selector != null) {
				// if the method call has no receiver, see if we can look it up
				// in the current context. If found, the inferredType(return type) of
				// that function is the value we are looking for.
				Object method = this.currentContext.getMember(((MessageSend)expression).selector);
				if(method instanceof MethodDeclaration) {
					return ((MethodDeclaration) method).inferredType;
				}
			}
		}

		return null;
	}

	protected void populateType(InferredType type, IObjectLiteral objLit, boolean isStatic) {
		if(objLit.getInferredType() == null) {
			objLit.setInferredType(type);
			if(objLit.getFields() != null) {
				for(int i = 0; i < objLit.getFields().length; i++) {
					IObjectLiteralField field = objLit.getFields()[i];

					char[] name = null;
					int nameStart = -1;

					if(field.getFieldName() instanceof SingleNameReference) {
						SingleNameReference singleNameReference = (SingleNameReference) field.getFieldName();
						name = singleNameReference.token;
						nameStart = singleNameReference.sourceStart;
					} else if(field.getFieldName() instanceof IStringLiteral) {
						IStringLiteral stringLiteral = (IStringLiteral) field.getFieldName();
						name = stringLiteral.source();
						nameStart = stringLiteral.sourceStart();
					} else
						continue; // not supporting this case right now

					Javadoc javaDoc = (Javadoc) field.getJsDoc();
					InferredType returnType = null;
					if(javaDoc != null) {
						if(javaDoc.memberOf != null) {
							char[] typeName = javaDoc.memberOf.getFullTypeName();
							convertAnonymousTypeToNamed(type, typeName);
							type.setIsDefinition(true);
						} else if(this.currentContext.isJsDocClass && javaDoc.property != null) {
							if(type.isAnonymous) {
								InferredType previousType = this.currentContext.currentType;
								if(previousType != null) {
									copyAnonymousTypeToNamed(type, previousType);
									objLit.setInferredType(type = this.currentContext.currentType = previousType);
								}

							}
						}
						if(javaDoc.returnType != null) {
							returnType = this.addType(changePrimitiveToObject(javaDoc.returnType.getFullTypeName()));
						}
					}

					// need to build the members of the anonymous inferred type
					if(field.getInitializer() instanceof IFunctionExpression) {
						IFunctionExpression functionExpression = (IFunctionExpression) field.getInitializer();
						InferredMember method =
								type.addMethod(name, functionExpression.getMethodDeclaration(), nameStart);
						method.isStatic = isStatic;
						if(javaDoc != null) {
							functionExpression.getMethodDeclaration().modifiers = javaDoc.modifiers;
						}
						handleFunctionDeclarationArguments(functionExpression.getMethodDeclaration(), javaDoc);
						if(returnType != null && functionExpression.getMethodDeclaration().getInferredType() == null) {
							functionExpression.getMethodDeclaration().setInferredType(returnType);
						}

					}
					// attribute
					else if (field.getInitializer() != null) {
						InferredAttribute attribute = type.findAttribute(name);
						if(attribute == null) {
							attribute = type.addAttribute(name, field.getInitializer(), nameStart);
							handleAttributeDeclaration(attribute, field.getInitializer());
							attribute.isStatic = isStatic;
							// @GINO: recursion might not be the best idea
							if(returnType != null) {
								attribute.type = returnType;
								// apply (force) type onto OL initializer
								if(field.getInitializer() instanceof ObjectLiteral) {
									((ObjectLiteral) field.getInitializer()).setInferredType(returnType);
								}
							} else {
								attribute.type = getTypeOf(field.getInitializer());
							}
							
							
						}
						
						//if attribute is function then create a function as well
						if(attribute.type != null && attribute.type.isFunction()) {
							if( type.findMethod(attribute.name, null) == null) {
								IAbstractFunctionDeclaration func = this.getFunction(field.getInitializer());
								if(func instanceof IFunctionDeclaration) {
									type.addMethod(name, (IFunctionDeclaration)func, nameStart);
								}
							}
						}
					}
				}
			}
		}
	}

	public void endVisit(IAssignment assignment) {
		popContext();
	}
	
	protected boolean handleAttributeDeclaration(InferredAttribute attribute) {
		return true;
	}

	protected boolean handleAttributeDeclaration(InferredAttribute attribute, IExpression initializer) {
		return true;
	}

	protected boolean handleFunctionCall(IFunctionCall messageSend) {
		return handleFunctionCall(messageSend, null);
	}

	protected boolean handleFunctionCall(IFunctionCall messageSend, LocalDeclaration assignmentExpression) {
		return true;
	}

	public boolean visit(IReturnStatement returnStatement) {
		this.pushContext();
		this.currentContext.currentReturn = returnStatement;
		
		if(currentContext.currentMethod != null) {
			if(returnStatement.getExpression() != null) {

				InferredType type = null;
				IExpression expression = returnStatement.getExpression();
				if(expression instanceof IObjectLiteral) {
					type = createAnonymousType((ObjectLiteral) expression);

					// set the start and end
					type.sourceStart = expression.sourceStart();
					type.sourceEnd = expression.sourceEnd();
				} else {
					type = getTypeOf(expression);
				}
				if(currentContext.currentMethod.getInferredType() == this.getVoidType() && type != null) {
					currentContext.currentMethod.setInferredType(type);
				} else if(currentContext.currentMethod.getInferredType() == this.getArrayType() 
							&& currentContext.currentMethod.getInferredType().referenceClass == null
							&& type != null && CharOperation.equals(type.name, TypeConstants.ARRAY[0])){
					currentContext.currentMethod.setInferredType(type);
				} else {
					/* If the return statement inferred type is null or
					 * the existing inferred return type and the statement return type are not
					 * equal and the return type is either not well known or is well
					 * known and the return type names are the same
					 * 
					 * This logic is to cover the scenario where the return type is a known type but
					 * is from a different instance of the InferEngine */
					boolean shouldSetToAny = !((MethodDeclaration) currentContext.currentMethod).isInferredJsDocType();
					if(type != null && shouldSetToAny) {
						// get the name of the current methods inferred return type
						String currentMethodInferredType = null;
						if(this.currentContext.currentMethod.getInferredType() != null
								&& this.currentContext.currentMethod.getInferredType().name != null) {
							currentMethodInferredType =
									new String(this.currentContext.currentMethod.getInferredType().name);
						}

						boolean returnTypesEqual = type.equals(currentContext.currentMethod.getInferredType());
						boolean returnTypeNamesEqual = (new String(type.name)).equals(currentMethodInferredType);
						boolean returnTypeIsWellKnown = WellKnownTypes.containsKey(type.name);

						shouldSetToAny =
								!returnTypesEqual
										&& (!returnTypeIsWellKnown || !(returnTypeIsWellKnown && returnTypeNamesEqual));
					}

					if(shouldSetToAny) {
						currentContext.currentMethod.setInferredType(null);
					}
				}
			}
		}
		return false;
	}
	
	/**
	 * @see org.eclipse.wst.jsdt.core.ast.ASTVisitor#endVisit(org.eclipse.wst.jsdt.core.ast.IReturnStatement)
	 */
	public void endVisit(IReturnStatement returnStatement) {
		this.popContext();
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.wst.jsdt.core.ast.ASTVisitor#endVisit(org.eclipse.wst.jsdt.core.ast.IFunctionCall)
	 */
	public void endVisit(IFunctionCall functionCall) {
		super.endVisit(functionCall);

		if(functionCall.getReceiver() instanceof FunctionExpression) {
			if (this.contextPtr == -1) {
				this.isTopLevelAnonymousFunction = true;
			}
			if (functionCall instanceof MessageSend && ((MessageSend) functionCall).getArguments() != null) {
				MethodDeclaration methodDeclaration = ((FunctionExpression) functionCall.getReceiver()).getMethodDeclaration();
				if (methodDeclaration != null && methodDeclaration.getArguments() != null) {
					IArgument[] declaredArguments = methodDeclaration.getArguments();
					IExpression[] sentArguments = ((MessageSend) functionCall).getArguments();
					for (int i = 0; i < declaredArguments.length; i++) {
						if (i >= sentArguments.length) {
							continue;
						}
						// if a sent argument now is a subtype of the declared argument, update the sent argument to be the type of the declared argument
						char[] parameterName = null;
						if ((parameterName = getName(sentArguments[i])) != null && passNumber == 2 && declaredArguments[i].getInferredType()!=null) {
							IASTNode node = (IASTNode) currentContext.getMember(parameterName);
							if (node instanceof IAbstractVariableDeclaration && ((IAbstractVariableDeclaration) node).getInferredType() != null) {
								if (((IAbstractVariableDeclaration) node).getInferredType().isNamed() && ((LocalDeclaration) node).getInferredType().equals(declaredArguments[i].getInferredType().getSuperType())) {
									((IAbstractVariableDeclaration) node).setInferredType(declaredArguments[i].getInferredType());
								}
							}
							else if (node instanceof IAssignment && ((IAssignment) node).getInferredType() != null) {
								if (((IAssignment) node).getInferredType().isNamed() && ((IAssignment) node).getInferredType().equals(declaredArguments[i].getInferredType().getSuperType())) {
									((IAssignment) node).setInferredType(declaredArguments[i].getInferredType());
								}
							}
						}
					}
				}
			}
		}
	}

	public void endVisit(IFunctionDeclaration methodDeclaration) {
		popContext();
	}

	public boolean visit(IFunctionDeclaration methodDeclaration) {
		pushContext();
		if(this.isTopLevelAnonymousFunction && this.currentContext.currentType == null) {
			this.currentContext.currentType = this.getInferredGlobal(true);
		} else if(!this.isTopLevelAnonymousFunction && this.currentContext.currentType != null && CharOperation.equals(this.currentContext.currentType.getName(), IIndexConstants.GLOBAL_SYMBOL)) {
			// if we are not a top level function and the current type is global, reset it to null.
			// this prevents this.anything style attributes from leaking to the global scope.
			this.currentContext.currentType = null;
		}

		this.isTopLevelAnonymousFunction = false;
		char[] methodName = methodDeclaration.getName();
		// if declaration didn't have name get name from inferred method if there is one
		if(methodName == null && methodDeclaration.getInferredMethod() != null) {
			methodName = methodDeclaration.getInferredMethod().name;
		}
		
		//set the function that contains this assignment
		if(this.passNumber == 1 && methodDeclaration instanceof AbstractMethodDeclaration && this.currentContext.currentMethod != null) {
			((AbstractMethodDeclaration)methodDeclaration).setContainingFunction(this.currentContext.currentMethod);
		}

		//always need to build arguments
		buildDefinedMembers(methodDeclaration.getStatements(), methodDeclaration.getArguments());
		
		//only on the first pass should JS doc be looked at
		if(passNumber == 1) {
			if(methodDeclaration.getJsDoc() != null) {
				InferredMethod method = null;
				Javadoc javadoc = (Javadoc) methodDeclaration.getJsDoc();
				createTypeIfNecessary(javadoc);
				if(javadoc.isConstructor) {
					InferredType type;
					if(!this.currentContext.isJsDocClass && methodName != null) {
						type = this.addType(methodName);
					} else {
						type = this.currentContext.currentType;
					}
					
					if(type != null) {
						handleJSDocConstructor(type, methodDeclaration, methodDeclaration.sourceStart());
					}
				} else if(javadoc.memberOf != null) {
					InferredType type = this.addType(javadoc.memberOf.getFullTypeName(), true);
					char[] name = methodName;
					int nameStart = methodDeclaration.sourceStart();
					if(name != null) {
						method = type.addMethod(methodName, methodDeclaration, nameStart);
					}
				} else if(javadoc.methodDef != null && this.currentContext.isJsDocClass) {
					InferredType type = this.currentContext.currentType;
					char[][] methName = javadoc.methodDef.getTypeName();
					int nameStart = ((MethodDeclaration) methodDeclaration).sourceStart;
					if(methName.length == 1) {
						method = type.addMethod(methName[0], methodDeclaration, nameStart);
					} else {
						method = type.addMethod(methName[methName.length - 1], methodDeclaration, nameStart);
						method.isStatic = true;
					}

				}

				if(javadoc.returnType != null) {
					InferredType type = this.addType(changePrimitiveToObject(javadoc.returnType.getFullTypeName()));
					methodDeclaration.setInferredType(type);
					((MethodDeclaration) methodDeclaration).bits |= ASTNode.IsInferredJsDocType;
				}

			}
			handleFunctionDeclarationArguments(methodDeclaration, methodDeclaration.getJsDoc());
		}
		
		// check if this is a constructor
		if(passNumber == 2) {
			if(methodName != null) {
				InferredType type = compUnit.findInferredType(methodName);
				InferredMethod inferMeth = methodDeclaration.getInferredMethod();
				
				//only a constructor if the method is in the found type, or is in a type with the same name
				if(type != null &&
						(inferMeth == null ||
						inferMeth.inType == null ||
						inferMeth.inType == type ||
						CharOperation.equals(inferMeth.inType.getName(), type.getName())) ) {
						 
					this.currentContext.currentType = type;
					type.setIsDefinition(true);
					
					if(inferMeth == null || !inferMeth.isConstructor) {
						int nameStart = methodDeclaration.sourceStart();
						type.addConstructorMethod(methodName, methodDeclaration, nameStart);
					}
				}
			}
		}
		this.currentContext.currentMethod = methodDeclaration;
		if(methodDeclaration.getInferredMethod() != null && methodDeclaration.getInferredMethod().inType != null) {
			this.currentContext.currentType = methodDeclaration.getInferredMethod().inType;
		}
		
		if(methodDeclaration.getInferredType() == null) {
			methodDeclaration.setInferredType(this.getVoidType());
		}
		
		return true;
	}
	
	protected void handleConstructor(InferredType type, IFunctionDeclaration methodDeclaration, int start, int end) {
		type.setIsDefinition(true);
		type.addConstructorMethod(type.name, methodDeclaration, start);
		type.updatePositions(start, end);
	}

	protected void handleJSDocConstructor(InferredType type, IFunctionDeclaration methodDeclaration, int nameStart) {
		Javadoc javadoc = (Javadoc) methodDeclaration.getJsDoc();
		type.setIsDefinition(true);
		type.addConstructorMethod(type.name, methodDeclaration, nameStart);

		if(javadoc.extendsType != null) {
			InferredType superType = this.addType(javadoc.extendsType.getFullTypeName());
			type.setSuperType(superType);
		}

	}
	
	protected void handleFunctionDeclarationArguments(IFunctionDeclaration methodDeclaration, IJsDoc jsdoc) {
		if(jsdoc == null || !(jsdoc instanceof Javadoc))
			return;
		Javadoc javadoc = (Javadoc) jsdoc;

		IArgument[] arguments = methodDeclaration.getArguments();
		if(arguments != null) {
			for(int i = 0; i < arguments.length; i++) {
				//skip if argument already has a named type
				InferredType currType = arguments[i].getInferredType();
				if(currType != null && !currType.isAnonymous) {
					//TODO: this could possibly be smarter
					continue;
				}

				InferredType paramType = null;
				JavadocSingleNameReference param = javadoc.findParam(arguments[i].getName());
				if(param != null) {
					if(param.types != null) {
						char[] name = {};
						for(int j = 0; j < param.types.length; j++) {
							// char []typeName=param.types[j].getFullTypeName();
							// make sure we are using the type version of Boolean, even if the user
							// entered boolean as the JSdoc type.
							char[] typeName = changePrimitiveToObject(param.types[j].getFullTypeName());
							if(j == 0) {
								name = typeName;
							} else {
								name = CharOperation.append(name, '|');
								name = CharOperation.concat(name, typeName);
							}
						}
						
						paramType = this.addType(name);
					}
				}
				/**
				 * http://code.google.com/p/jsdoc-toolkit/wiki/InlineDocs
				 **/
				else if(arguments[i].getJsDoc() != null) {
					if(((Javadoc) arguments[i].getJsDoc()).returnType != null) {
						paramType = this.addType(((Javadoc) arguments[i].getJsDoc()).returnType.getFullTypeName());
					}
				} else if(arguments[i].getComment() != null) {
					char[] comment = CharOperation.trim(arguments[i].getComment());
					boolean validForName = true;
					for(int j = 0; j < comment.length && validForName; j++) {
						validForName &=
								!CharOperation.isWhitespace(comment[j])
										&& (Character.isJavaIdentifierPart(comment[j]) || comment[j] == '.');
					}
					if(validForName) {
						paramType = this.addType(comment);
					}
				}
				
				if(paramType != null) {
					/* if the current type is not null (then it it is also anonymous)
					 * set the doced type as its parent */
					if(currType != null) {
						InferredType currSuperType = currType.getSuperType();
						currType.setSuperType(paramType);
						paramType.setSuperType(currSuperType);
						
						paramType = currType;
					}
					
					arguments[i].setInferredType(paramType);
				}
			}
		}
	}

	private void copyAnonymousTypeToNamed(InferredType inClass, InferredType toType) {
		if(toType == null)
			return;

		compUnit.inferredTypesHash.removeKey(inClass.name);
		if(inClass.methods != null) {
			toType.methods.addAll(inClass.methods);
		}
		if(inClass.attributes != null) {
			for(int i = 0; i < inClass.numberAttributes; i++) {
				toType.addAttribute(inClass.attributes[i]);
			}
		}

	}

	/**
	 * <p>
	 * Renames the given type to the given name. If there is a constructor on the type
	 * that is also renamed.
	 * </p>
	 * 
	 * @param type
	 *            {@link InferredType} to rename
	 * @param newTypeName
	 *            new type name for the given {@link InferredType}
	 */
	protected void renameType(InferredType type, char[] newTypeName) {
		//rename constructor on type if there is one
		InferredMethod constructor = type.findMethod(TypeConstants.INIT, null);
		if(constructor != null) {
			constructor.name = newTypeName;
		}
		
		//rename the type
		compUnit.inferredTypesHash.removeKey(type.name);
		type.name = newTypeName;
		compUnit.inferredTypesHash.put(newTypeName, type);
	}

	/**
	 * <p>
	 * Converts the given anonymous type to a named global type. If the given type is not anonymous
	 * then this is a no-op.
	 * </p>
	 * 
	 * @param type
	 *            anonymous {@link InferredType} to name
	 * @param newTypeName
	 *            new type name for the given anonymous {@link InferredType}
	 * 
	 * @see InferredType#isAnonymous
	 */
	protected void convertAnonymousTypeToNamed(InferredType type, char[] newTypeName) {
		if(type.isAnonymous) {
			this.renameType(type, newTypeName);
			type.isAnonymous = false;
			type.setIsGlobal(true);
		}
	}

	protected boolean isMatch(IExpression expr, char[][] names, int index) {
		char[] matchName = names[index];
		if(expr instanceof SingleNameReference) {
			SingleNameReference snr = (SingleNameReference) expr;
			return CharOperation.equals(snr.token, matchName);
		} else if(expr instanceof FieldReference && names.length > 1 && index > 0) {
			FieldReference fieldReference = (FieldReference) expr;
			if(CharOperation.equals(fieldReference.token, matchName)) {
				return isMatch(fieldReference.receiver, names, index - 1);
			}

		}
		return false;
	}

	/**
	 * @deprecated not used
	 */
	protected boolean isFunction(IFunctionCall messageSend, String string) {
		String[] names = string.split("\\."); //$NON-NLS-1$
		char[] functionName = names[names.length - 1].toCharArray();
		if(!CharOperation.equals(functionName, messageSend.getSelector())) {
			return false;
		}

		char[][] namesChars = new char[names.length][];
		for(int i = 0; i < namesChars.length; i++) {
			namesChars[i] = names[i].toCharArray();
		}
		if(names.length > 1) {
			return isMatch(messageSend.getReceiver(), namesChars, namesChars.length - 2);
		}
		return true;
	}

	protected boolean isFunction(IFunctionCall messageSend, char[][] names) {
		if(messageSend == null) {
			return false;
		}
		
		char[] functionName = names[names.length - 1];
		if(!CharOperation.equals(functionName, messageSend.getSelector())) {
			return false;
		}

		if(names.length > 1) {
			return isMatch(messageSend.getReceiver(), names, names.length - 2);
		}
		
		return true;
	}

	public void doInfer() {
		try {
			long time0 = 0;
			if(REPORT_INFER_TIME) {
				time0 = System.currentTimeMillis();
			}
			clearBuiltInTypes();
			
			ASTVisitor visitor = getVisitor(compUnit);
			if (visitor != null)
				compUnit.traverse(visitor);
			
			passNumber = 2;
			visitor = getVisitor(compUnit);
			if (visitor != null)
				compUnit.traverse(visitor);
			
			for(int i = 0; i < compUnit.numberInferredTypes; i++) {
				if(compUnit.inferredTypes[i].sourceStart < 0)
					compUnit.inferredTypes[i].sourceStart = 0;
			}

			if(REPORT_INFER_TIME) {
				long time = System.currentTimeMillis() - time0;
				System.err.println(getClass().getName() + " inferred " + new String(compUnit.getFileName()) + " in " //$NON-NLS-1$ //$NON-NLS-2$
						+ time + "ms"); //$NON-NLS-1$
			}
			this.compUnit = null;

		} catch(RuntimeException e) {
			org.eclipse.wst.jsdt.internal.core.util.Util.log(e, "error during type inferencing"); //$NON-NLS-1$
		}
	}

	protected InferredType addType(char[] className) {
		return addType(className, false);
	}

	/**
	 * Create a new inferred type with the given name
	 * 
	 * @param className
	 *            the name of the inferred type
	 * @param isDefinition
	 *            true if this unit defines the type
	 * @return new Inferred type
	 */
	protected InferredType addType(char[] className, boolean isDefinition) {		
		InferredType type = compUnit.addType(className, isDefinition, this.inferenceProvider.getID());

		return type;
	}

	protected final void pushContext() {
		Context newContext = new Context(currentContext);
		contexts[++contextPtr] = currentContext;
		currentContext = newContext;

	}

	protected final void popContext() {
		currentContext = contexts[contextPtr];
		contexts[contextPtr--] = null;
	}
	

	/**
	 * @deprecated not used internally, will be removed
	 */
	protected final boolean isInNamedMethod() {
		return this.currentContext.currentMethod != null && this.currentContext.currentMethod.getName() != null;
	}

	/**
	 * Finds a Var Declaration on the context from the name represented with the expression
	 */
	protected IAbstractVariableDeclaration getVariable(IExpression expression) {
		char[] name = null;

		if(expression instanceof ISingleNameReference) {
			name = ((ISingleNameReference) expression).getToken();
		} else if(expression instanceof IFieldReference) {
			IReference ref = getRoot((IFieldReference)expression);
			if(ref != null && ref instanceof SingleNameReference) {
				name = ((SingleNameReference)ref).getToken();
			}
		}
		
		if(name != null) {
			Object var = this.currentContext.getMember(name);
			if(var instanceof IAbstractVariableDeclaration) {
				return (IAbstractVariableDeclaration) var;
			}

		}
		return null;

	}

	/**
	 * Finds a assignment on the context from the name represented with the expression
	 */
	protected IAssignment getAssignment(IExpression expression) {
		char[] name = null;

		if(expression instanceof ISingleNameReference) {
			name = ((ISingleNameReference) expression).getToken();
		} else if(expression instanceof IFieldReference) {
			IReference ref = getRoot((IFieldReference)expression);
			if(ref != null && ref instanceof SingleNameReference) {
				name = ((SingleNameReference)ref).getToken();
			}
		}
		
		if(name != null) {
			Object assignment = this.currentContext.getMember(name);
			if(assignment instanceof IAssignment) {
				return (IAssignment) assignment;
			}
		}
		
		return null;
	}

	/**
	 * <p>
	 * Finds a Function Declaration on the context from the name represented
	 * with the expression
	 * </p>
	 * 
	 * <p>
	 * Supported:
	 * <ul>
	 * <li>{@link ISingleNameReference}</li>
	 * <li>{@link ILocalDeclaration}</li>
	 * </ul>
	 * </p>
	 */
	protected IAbstractFunctionDeclaration getFunction(IExpression expression) {
		IAbstractFunctionDeclaration function = null;
		
		char[] name = null;
		if(expression instanceof ISingleNameReference) {
			name = ((ISingleNameReference) expression).getToken();
			
			Object method = this.currentContext.getMember(name);
			if(method instanceof IAbstractFunctionDeclaration) {
				function = (IAbstractFunctionDeclaration) method;
			} else if(method instanceof ILocalDeclaration) {
				IExpression init = ((ILocalDeclaration) method).getInitialization();
				if(init instanceof IFunctionExpression) {
					function = ((IFunctionExpression)init).getMethodDeclaration();
				}
			}
		} else if(expression instanceof IFieldReference) {
			InferredType receiverType = this.getReceiverType(((IFieldReference) expression).getReceiver(), false);
			if(receiverType != null) {
				InferredMethod inferredMethod = receiverType.findMethod(((IFieldReference) expression).getToken(), null);
				if(inferredMethod != null) {
					function = inferredMethod.getFunctionDeclaration();
				}
			}
			name = ((IFieldReference) expression).getToken();
		} else if(expression instanceof MessageSend) {
			name = ((MessageSend)expression).selector;
			if(name != null) {
				// look up the function in the current context, we want to get
				// to its return statement eventually.
				Object method = this.currentContext.getMember(name);
				if(method instanceof IAbstractFunctionDeclaration) {
					IAbstractFunctionDeclaration calledFunction = (IAbstractFunctionDeclaration) method;
					if(calledFunction.getStatements() != null) {
						IProgramElement[] statements = calledFunction.getStatements();
						// this is a bit of a guess, but look for a return statement
						// if found and it is returning a function, then use that
						// if not we just return nothing, no harm done.
						for(int i = 0; i < statements.length; i++) {
							if(statements[i] instanceof IReturnStatement) {
								if(((IReturnStatement)statements[i]).getExpression() instanceof IFunctionExpression) {
									function = ((IFunctionExpression) ((IReturnStatement)statements[i]).getExpression()).getMethodDeclaration();
									break;
								}
							}
						}
					}
				}
			}
		}
		
		return function;
	}

	private void buildDefinedMembers(IProgramElement[] statements, IArgument[] arguments) {

		if(arguments != null) {
			for(int i = 0; i < arguments.length; i++) {
				this.currentContext.addMember(arguments[i].getName(), arguments[i]);
			}
		}
		if(statements != null) {
			for(int i = 0; i < statements.length; i++) {
				if(statements[i] instanceof ILocalDeclaration) {
					ILocalDeclaration local = (ILocalDeclaration) statements[i];
					this.currentContext.addMember(local.getName(), local);
				} else if(statements[i] instanceof IAbstractFunctionDeclaration) {
					IAbstractFunctionDeclaration method = (IAbstractFunctionDeclaration) statements[i];
					if(method.getName() != null)
						this.currentContext.addMember(method.getName(), method);
				}
			}
		}
	}

	private static boolean isThis(IExpression expression) {
		return expression instanceof ASTNode && ((ASTNode)expression).isThis();
	}

	/* This method is used to determined the inferred type of a LHS Expression.
	 * 
	 * It could return null.
	 * 
	 * a.b.c */
	private InferredType getInferredType(IExpression expression) {

		InferredType type = null;

		/* this */
		if(expression instanceof IThisReference) {
			type = this.currentContext.currentType;
		}
		/* foo (could be a Type name or a reference to a variable) */
		else if(expression instanceof SingleNameReference) {
			//check for local variable first
			IAbstractVariableDeclaration varDecl = this.getVariable(expression);
			if(varDecl != null) {
				type = varDecl.getInferredType();
			} 
			
			//if not found type yet check for assignment 
			IAssignment assignment = null;
			if(type == null) {
				assignment = getAssignment(expression);
				if(assignment != null) {
					type = assignment.getInferredType();
				}
			}
			
			/* if not found type yet and there was no declaration or assignment,
			 * or the found type is Function then check if there is a known type
			 * with the same name as the SNR. */
			if((type == null && varDecl == null && assignment == null) ||
						(type != null && type.isFunction())) {
				
				char[] possibleTypeName = constructTypeName(expression);
				if(possibleTypeName != null) {
					/* if pre-existing type, use that
					 * else check if known type name */
					InferredType existingType = compUnit.findInferredType(possibleTypeName);
					if(existingType != null) {
						type = existingType;
					} else if(WellKnownTypes.containsKey(possibleTypeName) ||
								this.isKnownType(possibleTypeName)) {
						
						type = addType(possibleTypeName, false);
					}
				}
			}
		}
		/* foo.bar.xxx... */
		else if(expression instanceof FieldReference) {
			char[] possibleTypeName = constructTypeName(expression);

			if(possibleTypeName != null) {
				// search the defined types in the context
				type = compUnit.findInferredType(possibleTypeName);
			}

			if(type == null && isPossibleClassName(possibleTypeName)) {
				type = addType(possibleTypeName, true);
			}

			/* Continue the search by trying to resolve further down the name
			 * because this token of the field reference could be a member of a
			 * type or instance of a type */
			if(type == null) {
				FieldReference fRef = (FieldReference) expression;

				// this
				InferredType parentType = getInferredType(fRef.receiver);

				if(parentType != null) {
					// check the members and return type
					InferredAttribute typeAttribute = parentType.findAttribute(fRef.token);

					if(typeAttribute != null) {
						type = typeAttribute.type;
					}
				}
			}

		}

		return type;
	}

	/**
	 * @deprecated - here for compatibility
	 */
	protected InferredType getInferredType2(IExpression fieldReceiver) {
		InferredType receiverType = null;
		IAbstractVariableDeclaration var = getVariable(fieldReceiver);
		if(var != null) {
			receiverType = createAnonymousType(var);
		} else {
			if(this.inferredGlobal != null && fieldReceiver instanceof ISingleNameReference) {
				char[] name = ((ISingleNameReference) fieldReceiver).getToken();
				InferredAttribute attr = this.inferredGlobal.findAttribute(name);
				if(attr != null) {
					receiverType = attr.type;
				}
			}

		}
		return receiverType;
	}

	protected boolean isKnownType(char[] possibleTypeName) {
		return false;
	}

	/* For SNR it returns the name
	 * For FR it construct a Qualified name separated by '.'
	 * 
	 * If at any point it hits a portion of the Field reference that is
	 * not supported (such as a function call, a prototype, or this ) */
	protected final char[] constructTypeName(IExpression expression) {
		return Util.getTypeName(expression);
	}

	public boolean visit(IObjectLiteral literal) {
		if(this.passNumber == 1 && literal.getInferredType() == null) {
			createAnonymousType(literal);
		}
		pushContext();
		this.currentContext.currentType = literal.getInferredType();
		return true;
	}

	public void endVisit(IObjectLiteral literal) {
		popContext();
	}

	/**
	 * Overridden by client who wish to update the infer options
	 * 
	 * @param options
	 */
	public void initializeOptions(InferOptions options) {
	}

	protected boolean isPossibleClassName(char[] name) {
		return false;
	}

	/**
	 * Get the Script file this inference is being done on
	 * 
	 * @return
	 */
	public IScriptFileDeclaration getScriptFileDeclaration() {
		return this.compUnit;
	}

	public InferredType findDefinedType(char[] className) {
		return compUnit.findInferredType(className);
	}
	
	protected Object findDefinedMember(char[] memberName) {
		return currentContext.getMember(memberName);
	}

	protected char[] changePrimitiveToObject(char[] name) {
		/*
		 * Changes the first character of the name of the primitive types to
		 * uppercase. This will allow future reference to the object wrapper
		 * instead of the primitive type.
		 */
		if(CharOperation.equals(name, TypeConstants.BOOLEAN, false)) {
			return this.getBooleanType().getName();
		}
		
		return name;
	}
	
	/**
	 * @return {@link InferredType} for the String type
	 */
	protected InferredType getStringType() {
		if(fStringType == null) {
			fStringType = this.addType(TypeConstants.JAVA_LANG_STRING[0]);
		}
		
		return fStringType;
	}
	
	/**
	 * @return {@link InferredType} for the Number type
	 */
	protected InferredType getNumberType() {
		if(fNumberType == null) {
			fNumberType = this.addType(TypeConstants.NUMBER[0]);
		}
		
		return fNumberType;
	}
	
	/**
	 * @return {@link InferredType} for the Boolean type
	 */
	protected InferredType getBooleanType() {
		if (fBooleanType == null) {
			fBooleanType = this.addType(TypeConstants.BOOLEAN_OBJECT[0]);
		}
		
		return fBooleanType;
	}
	
	/**
	 * @return {@link InferredType} for the Function type
	 */
	protected InferredType getFunctionType() {
		if(fFunctionType == null) {
			fFunctionType = this.addType(TypeConstants.FUNCTION[0]);
		}
		
		return fFunctionType;
	}
	
	/**
	 * @return {@link InferredType} for the Array type
	 */
	protected InferredType getArrayType() {
		if(fArrayType == null) {
			fArrayType = this.addType(TypeConstants.ARRAY[0]);
		}
		
		return fArrayType;
	}
	
	/**
	 * @return {@link InferredType} for the Void type
	 */
	protected InferredType getVoidType() {
		if(fVoidType == null) {
			fVoidType = this.addType(TypeConstants.VOID);
		}
		
		return fVoidType;
	}
	
	/**
	 * @return {@link InferredType} for the Object type
	 */
	protected InferredType getObjectType() {
		if(fObjectType == null) {
			fObjectType = this.addType(TypeConstants.OBJECT);
		}
		
		return fObjectType;
	}

	/**
	 * <p>
	 * Gets the name of the given expression.
	 * </p>
	 * 
	 * <p>
	 * Supported:
	 * <ul>
	 * <li>{@link ISingleNameReference}</li>
	 * <li>{@link IFieldReference}</li>
	 * <li>{@link IAssignment}</li>
	 * </ul>
	 * </p>
	 * 
	 * @param expression
	 *            {@link IExpression} to get the name for
	 * 
	 * @return name of the given {@link IExpression} or <code>null</code> if none
	 *         can be determined
	 */
	protected char[] getName(IExpression expression) {
		char[] name = null;

		if(expression instanceof ISingleNameReference) {
			name = ((ISingleNameReference) expression).getToken();
		} else if(expression instanceof IFieldReference) {
			name = ((IFieldReference) expression).getToken();
		} else if(expression instanceof IAssignment) {
			name = this.getName(((IAssignment) expression).getLeftHandSide());
		}

		return name;
	}

	/**
	 * <p>
	 * Given a variable name and an initialization expression determines the
	 * type to initialize the variable with the given name to.
	 * </p>
	 * 
	 * @param variableName
	 *            name of the variable to be initialized
	 * @param initialization
	 *            the initialization expression used to initialize the
	 *            variable with the given name
	 * 
	 * @return {@link InferredType} to initialize the variable with the given
	 *         name with
	 */
	private InferredType getTypeForVariableInitialization(char[] variableName, IExpression initialization) {
		InferredType type = this.getTypeOf(initialization);

		/* if the initialization type is not indexed and the variable declaration is in the global scope
		 * rename the type to a globally anonymous type and mark it as a global type
		 */
		boolean isGlobal = this.isGlobal(variableName);
		if(type != null && !type.isIndexed() && isGlobal) {
				char[] globalTypeName = createAnonymousGlobalTypeName(variableName);
				this.renameType(type, globalTypeName);
				type.isAnonymous = true;
				type.setIsGlobal(true);
		} else if(type == null && isGlobal && this.passNumber == 2) {
			type = this.createAnonymousGlobalType(variableName);
		}

		return type;
	}
	
	/**
	 * <p>
	 * Will create a type to assign to given the receiver that is being assigned to, the current
	 * type that is or will be assigned to the receiver, and the assignment expression that will be
	 * used for the assignment.
	 * </p>
	 * 
	 * <p>
	 * <b>NOTE:</b> This does not actually deal with the assignment, it just creates the type to assign
	 * to and updates the type for the given receiver.
	 * </p>
	 * 
	 * @param receiver
	 *            the receiver to update the type for
	 * @param currentReceiverType
	 *            current type that is or will be assigned to the receiver
	 * 
	 * @return {@link InferredType} that was created to do the assignment to or the given current
	 *         receiver type if no new type was created
	 */
	private InferredType createTypeToAssignTo(IExpression receiver, InferredType currentReceiverType) {
		char[] varName = this.getName(receiver);
		InferredType newType = null;
		
		/* If the current receiver type is not anonymous and is not a this statement,
		 * and the receiver is not a type (rather then instance of a type, then
		 * create a new anonymous type with current type as the parent.
		 * 
		 * else use the given current receiver type */
		if(!currentReceiverType.isAnonymous && !isThis(receiver)
				&& !CharOperation.equals(currentReceiverType.name, varName) && !this.isExpressionAType(receiver)) {
			
			/* if the variable being assigned to is in the global scope then
			 * need to create a global type
			 * 
			 * else create a local anonymous type
			 */
			boolean isGlobal = this.isGlobal(varName);
			if(isGlobal) {
				/* if current type is a function create a new type with the var name
				 * else create new anonymous global type */
				if(currentReceiverType.isFunction()) {
					newType = this.addType(varName, true);
				} else {
					newType = this.createAnonymousGlobalType(varName);
				}
			} else {
				newType = this.createAnonymousType(receiver, currentReceiverType);
			}
		}

		/* if created a new type set its super type to the original type and update the type for the receiver
		 * 
		 * else just return the original given current receiver type */
		if(newType != null) {
			newType.setSuperType(currentReceiverType);
			this.setTypeOf(receiver, newType);
		} else {
			newType = currentReceiverType;
		}
		
		return newType;
	}
	
	/**
	 * <p>
	 * Clears out all of the built in types.
	 * </p>
	 */
	private void clearBuiltInTypes() {
		fStringType = null;
		fNumberType = null;
		fBooleanType = null;
		fFunctionType = null;
		fArrayType = null;
		fVoidType = null;
		fObjectType = null;
	}
	
	/**
	 * <p>
	 * This method is intended to take a chain of field references and
	 * determine the type that the last field should be or is defined on.
	 * </p>
	 * 
	 * <p>
	 * EX: <code>foo.bar.awesome.crazy = 42;</code><br>
	 * <br>
	 * If that is the entirety of the file and the receiver of the
	 * <code>foo.bar.awesome.crazy</code> statement is given to this function,
	 * so the <code>foo.bar.awesome</code> part, then this function will
	 * create a <code>foo</code> field on the global inferred type and and
	 * then give it a type that has a <code>bar</code> field, and then give
	 * the <code>bar</code> field a type with an <code>awesome</code> field
	 * and then finally return a new type assigned to the <code>awesome</code>
	 * field such that some other code can deal with assigning the
	 * <code>crazy</code> field with whatever type is on the right hand side
	 * of the assignment.
	 * </p>
	 * 
	 * @param receiver
	 *            the receiver side of a {@link FieldReference} to get the
	 *            type for
	 * 
	 * @param defineRoot
	 *            Has two purposes. If the root of the field reference has no
	 *            type and this is <code>true</code> a type will be created.
	 *            If the root of this field reference does not have a type and
	 *            this is <code>false</code> no root type will be created an
	 *            thus no type will be returned by this method. When there is
	 *            a root type if this argument is <code>true</code> then the
	 *            type on the root will be marked as a definition, else if
	 *            <code>false</code> the root will not be marked as a
	 *            definition.
	 * 
	 * @return {@link InferredType} associated with the given receiver side of
	 *         a {@link FieldReference}
	 */
	protected InferredType getReceiverType(IExpression receiver, boolean defineRoot) {
		InferredType receiverType = null;
		IExpression current = receiver;
		List recievers = new ArrayList();
		InferredType rootType = null;
		
		/* Find the SingleNameReference that the reference chain starts with
		 * or the root type if the chain starts with a THIS statement */
		while(current != null && !(current instanceof SingleNameReference) && rootType == null) {
			if(current instanceof FieldReference) {
				recievers.add(current);
				current = ((FieldReference) current).getReceiver();
			} else if(current instanceof ThisReference) {
				rootType = this.currentContext.currentType;
				((ThisReference) current).setInferredType(rootType);
				current = null;
			} else {
				current = null;
			}
		}
		
		//if the root was a single name then determine or create its type
		IAbstractVariableDeclaration rootVarDecl = null;
		IAssignment rootAssignment = null;
		if(rootType == null && current instanceof SingleNameReference) {
			
			//first check if there is a type with the same name as the single name reference
			char[] name = ((SingleNameReference) current).getToken();
			rootType = this.findDefinedType(name);
			
			// if the single name reference is a function then create a type using the function name
			if(rootType == null) {
				IFunctionDeclaration func = this.getDefinedFunction(current);
				if(func != null) {
					rootType = this.addType(name, true);
					rootType.setNameStart(current.sourceStart());
					rootType.setSourceEnd(current.sourceEnd());
				}
			}
			
			// if single name reference is to a variable
			if(rootType == null) {
				rootVarDecl = this.getVariable(current);
				if(rootVarDecl != null) {
					rootType = rootVarDecl.getInferredType();
					
					/* if variable does not already have an inferred type create an anonymous one
					 * or if the receiver type is not anonymous and is the expression is not a type then
					 * create a new anonymous sub type to do the assignment to */
					
					if(rootType == null || (!rootType.isAnonymous && !rootVarDecl.isType())) {
						/* if global then create anonymous global type and set super type as current root type
						 * else create anonymous type using current root type as super type */
						boolean isGlobal = this.isGlobal(name);
						if(isGlobal) {
							InferredType globalType = this.createAnonymousGlobalType(name);
							globalType.setSuperType(rootType);
							rootType = globalType;
							rootType.setIsDefinition(true);
							rootVarDecl.setInferredType(rootType);
						} else if(defineRoot) {
							rootType = this.createAnonymousType(current, rootType);
							rootType.setIsDefinition(true);
							rootVarDecl.setInferredType(rootType);
						}
					}
				}
			}
			
			//if single name reference is to a field on the inferred 'global' type
			if(rootType == null && this.inferredGlobal != null) {
				InferredAttribute attr = this.getInferredGlobal(false).findAttribute(name);
				if(attr != null) {
					if(attr.type == null) {
						attr.type = this.createAnonymousGlobalType(attr.name);
					}
					rootType = attr.type;
				} else {
					InferredMethod meth = this.getInferredGlobal(false).findMethod(name, null);
					if(meth != null) {
						rootType = this.addType(name, true);
						rootType.setNameStart(current.sourceStart());
						rootType.setSourceEnd(current.sourceEnd());
					}
				}
			}
			
			// if single name reference is to an existing assignment with no declaration
			if(rootType == null) {
				rootAssignment = this.getAssignment(current);
				if(rootAssignment != null) {
					rootType = rootAssignment.getInferredType();
				}
			}
			
			/* else if define root create a new anonymous global type */
			if(rootType == null && defineRoot) {
				rootType = this.createAnonymousGlobalType(name);
			}
		}
		
		/* if determined a root type, and there is no case where we should not,
		 * make sure there is fields and types built up for the rest of the reference chain */
		if(rootType != null) {
			/* only define root if requested and root not part of long chain,
			 * or the root was already defined somewhere else in this file
			 * 
			 * IE: foo.bar.blarg = 42, foo is not defined here
			 * 	   foo.bar = 42, foo is defined here */
			if(defineRoot && (recievers.isEmpty() || rootVarDecl != null || rootAssignment != null)) {
				rootType.setIsDefinition(true);
			}
			
			InferredType currentType = rootType;
			for(int i = recievers.size()-1; i >= 0; --i) {
				FieldReference ref = (FieldReference)recievers.get(i);
				
				InferredAttribute attr = currentType.findAttribute(ref.getToken());
				if(attr != null) {
					if(attr.type != null) {
						currentType = attr.type;
					} else {
						attr.type  = this.createAnonymousType(attr, null);
						currentType = attr.type;
					}
				} else {
					InferredMethod meth = currentType.findMethod(ref.getToken(), null);
					if(meth != null) {
						char[] typeName = CharOperation.concatWith(ref.asQualifiedName(), '.');
						currentType = this.addType(typeName, true);
					} else {
						attr = currentType.addAttribute(ref.getToken(), ref, ref.sourceStart);
						
						if(currentType == this.getInferredGlobal(false)) {
							attr.type = this.createAnonymousGlobalType(attr.name);
							attr.type.setIsDefinition(true);
						} else {
							attr.type = this.createAnonymousType(attr, null);
						}
						currentType = attr.type;
					}
				}
			}
			
			//set the last type in the chain as the receiver type
			receiverType = currentType;
		}
		
		return receiverType;
	}
	
	/**
	 * @param define
	 *            <code>true</code> to define the inferred global type if one
	 *            is not yet defined, <code>false</code> otherwise
	 * 
	 * @return inferred global type, or <code>null</code> if none is yet
	 *         defined and <code>define</code> was given as <code>false</code>
	 */
	protected InferredType getInferredGlobal(boolean define) {
		if(this.inferredGlobal == null && define) {
			this.inferredGlobal = addType(IIndexConstants.GLOBAL_SYMBOL, true);
			this.inferredGlobal.isAnonymous = true;
			this.inferredGlobal.setIsGlobal(true);
		}
		
		return this.inferredGlobal;
	}
	
	/**
	 * <p>
	 * Determine if the root of the given expression is global or not.
	 * </p>
	 * 
	 * @param expr
	 *            Determine if the root of this expression is global or not
	 * 
	 * @return <code>true</code> if the root of the given expression is
	 *         global, <code>false</code> otherwise
	 */
	private boolean isRootGlobal(IExpression expr) {
		boolean isGlobal = false;
		
		IReference root = null;
		if(expr instanceof SingleNameReference) {
			root = (SingleNameReference) expr;
		} else if(expr instanceof FieldReference) {
			root = getRoot((FieldReference)expr);
		}
		
		/* if root is a single name reference then determine if it is global
		 * else if no root then assume global */
		if(root != null && root instanceof ISingleNameReference) {
			isGlobal = this.isGlobal(((ISingleNameReference)root).getToken());
		} else if(root != null && root instanceof IThisReference) {
			isGlobal = this.currentContext.currentType == this.getInferredGlobal(false);
		} else if(root == null){
			isGlobal = true;
		}
		
		return isGlobal;
	}
	
	/**
	 * <p>
	 * Determines if the given variable name is global.
	 * </p>
	 * 
	 * @param name
	 *            determine if there is a global variable with this name
	 * 
	 * @return <code>true</code> if there is a global variable with this name,
	 *         <code>false</code> otherwise
	 */
	protected boolean isGlobal(char[] name) {
		boolean isGlobal = false;
		
		if (name == null)
			return isGlobal;
		
		//check the root context
		Object globalMember;
		Object currentContextMember = this.currentContext.getMember(name);
		if(this.contexts[0] != null) {
			globalMember = this.contexts[0].getMember(name);
		} else {
			globalMember = currentContextMember;
		}
		
		/* is global if global member with same name is not null and from the current context
		 * the first member with that name is also the global member, this is to cover the case
		 * with a shadowing local variable */
		isGlobal = globalMember != null && currentContextMember == globalMember;
		
		/* if not determined to be global then check if the current context member
		 * is an assignment. If it is then that assignment is an assignment without
		 * a local declaration which means it is global */
		if(!isGlobal) {
			isGlobal = currentContextMember instanceof Assignment;
		}
		
		//if not determined to be global yet then check inferred global type
		if(!isGlobal) {
			globalMember = null;
			InferredType inferredGlobal = this.getInferredGlobal(false);
			if(inferredGlobal != null) {
				globalMember = inferredGlobal.findAttribute(name);
				
				if(globalMember == null) {
					globalMember = inferredGlobal.findMethod(name, null);
				}
			}
			
			isGlobal = globalMember != null;
		}
		
		/* if not determined to be global yet and no global member or
		 * local member found assume to be global */
		if(!isGlobal) {
			if(globalMember == null && currentContextMember == null) {
				isGlobal = true;
			}
		}
		
		return isGlobal;
	}
	
	/**
	 * <p>
	 * Given an {@link IFieldReference} finds the root
	 * {@link SingleNameReference}.
	 * </p>
	 * 
	 * @param ref
	 *            {@link IFieldReference} to find the root
	 *            {@link SingleNameReference} for
	 * 
	 * @return {@link SingleNameReference} that is the root of the given
	 *         {@link IFieldReference}, or <code>null</code> if it can not be
	 *         found.
	 */
	private static IReference getRoot(IFieldReference ref) {
		IReference root = null;
		
		IExpression current = ref;
		while(root == null && current != null) {
			if(current instanceof IFieldReference) {
				current = ((IFieldReference) current).getReceiver();
			} else if(current instanceof SingleNameReference) {
				root = (SingleNameReference)current;
			} else if(current instanceof IThisReference) {
				root = (IThisReference)current;
			} else {
				current = null;
			}
		}
		
		return root;
	}
	
	/**
	 * <p>
	 * Determines if the given parent expression contains or is the given
	 * needle expression.
	 * </p>
	 * 
	 * <p>
	 * Handles:
	 * <ul>
	 * <li>{@link IBinaryExpression}</li>
	 * </ul>
	 * </p>
	 * 
	 * @param parent
	 *            determine if the given needle is or is contained by this
	 *            parent expression
	 * @param needle
	 *            determine if the this needle is or is contained by the given
	 *            parent expression
	 * 
	 * @return <code>true</code> if the given needle is or is contained by the
	 *         given parent expression, <code>false</code> otherwise
	 */
	private static boolean expressionContains(IExpression parent, IExpression needle) {
		boolean contains = false;
		
		LinkedList expressions = new LinkedList();
		expressions.add(parent);
		
		while(expressions.size() > 0 && !contains) {
			IExpression current = (IExpression)expressions.removeFirst();
			
			contains = needle == current;
			
			if(!contains) {
				if(current instanceof IBinaryExpression) {
					expressions.add(((IBinaryExpression) current).getLeft());
					expressions.add(((IBinaryExpression) current).getRight());
				} else if(current instanceof Assignment) {
					expressions.add(((Assignment) current).getLeftHandSide());
					expressions.add(((Assignment) current).getExpression());
				}
			}
		}
		
		return contains;
	}
	
	/**
	 * <p>
	 * Determines if the given expression is a type rather then an instance of
	 * a type.
	 * </p>
	 * 
	 * @param expr
	 *            determine if this expression is a type rather then an
	 *            instance of a type
	 * 
	 * @return <code>true</code> if the given expression is a type,
	 *         <code>false</code> if the given expression is the instance of a
	 *         type or unknown
	 */
	private boolean isExpressionAType(IExpression expr) {
		boolean isType = false;
		
		if(expr instanceof IAssignment) {
			isType = ((IAssignment) expr).isType();
		} else if(expr instanceof IAbstractVariableDeclaration) {
			isType = ((IAbstractVariableDeclaration) expr).isType();
		} else if(expr instanceof IFieldReference) {
			IExpression receiver = ((IFieldReference) expr).getReceiver();
			InferredType receiverType = this.getTypeOf(receiver);
			if(receiverType != null) {
				InferredAttribute attr = receiverType.findAttribute(((IFieldReference) expr).getToken());
				isType = attr != null && attr.isType();
			}
		} else if(expr instanceof ISingleNameReference) {
			IAbstractVariableDeclaration varDecl = this.getVariable(expr);
			if(varDecl != null) {
				isType = varDecl.isType();
			}
			
			if(!isType) {
				IAssignment assign = this.getAssignment(expr);
				if(assign != null) {
					isType = assign.isType();
				}
			}
			
			if(!isType) {
				IAbstractFunctionDeclaration funcDecl = this.getFunction(expr);
				if(funcDecl != null && funcDecl.getName() != null) {
					InferredType typeDefinedByFunc = this.findDefinedType(funcDecl.getName());
					isType = typeDefinedByFunc != null;
				}
			}
			
			if(!isType) {
				InferredType existingType =this.compUnit.findInferredType(((ISingleNameReference) expr).getToken());
				isType = existingType != null;
			}
		} else if(expr instanceof IThisReference) {
			isType = true;
		}
		
		return isType;
	}

	protected InferredType createAnonymousTypeForMixin(IExpression mixInto, InferredType parentType) {
		InferredType mixIntoType;
		IAbstractVariableDeclaration localVar = getVariable(mixInto);
		char[] varName = getName(mixInto);
		if (mixInto instanceof ISingleNameReference && (localVar == null || isGlobal(varName))) {
			mixIntoType = createAnonymousGlobalType(varName);
			mixIntoType.setSuperType(parentType);
		}
		else {
			mixIntoType = createAnonymousType(mixInto, parentType);
		}
		mixIntoType.isObjectLiteral = false;
		return mixIntoType;
	}

	protected InferredType getAttributeType(char[] attName, IExpression receiver, boolean defineRoot) {
		InferredType attrType = null;
		InferredType receiverType = this.getReceiverType(receiver, defineRoot);
		if (receiverType != null) {
			InferredAttribute attr = receiverType.findAttribute(attName);
			if (attr != null && attr.type != null) {
				attrType = attr.type;
			}
		}
		return attrType;
	}
	
	/**
	 * Return a visitor to traverse the given compilation unit's AST.
	 * Subclasses may override to provide a more minimal implementations while
	 * retaining use of utility methods from the base InferEngine.
	 * 
	 * @return a visitor for use with the given compilation unit and current
	 *         engine states, or <code>null</code>
	 */
	protected ASTVisitor getVisitor(CompilationUnitDeclaration compilationUnit) {
		return this;
	}
}