org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/structure/constraints/SuperTypeConstraintsModel.java - jdt/eclipse.jdt.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2011 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.jdt.internal.corext.refactoring.structure.constraints;

 import java.util.AbstractSet;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Set;

 import org.eclipse.jdt.core.dom.CastExpression;
 import org.eclipse.jdt.core.dom.IMethodBinding;
 import org.eclipse.jdt.core.dom.ITypeBinding;
 import org.eclipse.jdt.core.dom.IVariableBinding;
 import org.eclipse.jdt.core.dom.Name;
 import org.eclipse.jdt.core.dom.Type;

 import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.CompilationUnitRange;
 import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.TType;
 import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.TypeEnvironment;
 import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.CastVariable2;
 import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.ConstraintVariable2;
 import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.ITypeConstraint2;
 import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.ImmutableTypeVariable2;
 import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.IndependentTypeVariable2;
 import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.ParameterTypeVariable2;
 import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.ReturnTypeVariable2;
 import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.SubTypeConstraint2;
 import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TypeEquivalenceSet;
 import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TypeVariable2;
 import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.VariableVariable2;
 import org.eclipse.jdt.internal.corext.refactoring.util.RefactoringASTParser;


 /**
  * Type constraints model to hold all type constraints to replace type occurrences by a given supertype.
  *
  * @since 3.1
  */
 public final class SuperTypeConstraintsModel {

 	/** Customized implementation of a hash set
 	 * @param <E> the element type */
 	private static class HashedSet<E> extends AbstractSet<E> {

 		/** The backing hash map */
 		private final Map<E, E> fImplementation= new HashMap<E, E>();

 		/*
 		 * @see java.util.AbstractCollection#add(java.lang.Object)
 		 */
 		@Override
 		public final boolean add(final E object) {
 			return fImplementation.put(object, object) == null;
 		}

 		/**
 		 * Attempts to add the specified object to this set.
 		 *
 		 * @param object the object to add
 		 * @return An already existing object considered equal to the specified one, or the newly added object
 		 */
 		public final E addExisting(final E object) {
 			final E result= fImplementation.get(object);
 			if (result != null)
 				return result;
 			fImplementation.put(object, object);
 			return object;
 		}

 		/*
 		 * @see java.util.AbstractCollection#clear()
 		 */
 		@Override
 		public final void clear() {
 			fImplementation.clear();
 		}

 		/*
 		 * @see java.util.AbstractCollection#contains(java.lang.Object)
 		 */
 		@Override
 		public final boolean contains(final Object object) {
 			return fImplementation.containsKey(object);
 		}

 		/*
 		 * @see java.util.AbstractCollection#isEmpty()
 		 */
 		@Override
 		public final boolean isEmpty() {
 			return fImplementation.isEmpty();
 		}

 		/*
 		 * @see java.util.AbstractCollection#iterator()
 		 */
 		@Override
 		public final Iterator<E> iterator() {
 			return fImplementation.keySet().iterator();
 		}

 		/*
 		 * @see java.util.AbstractCollection#remove(java.lang.Object)
 		 */
 		@Override
 		public final boolean remove(final Object object) {
 			return fImplementation.remove(object) == object;
 		}

 		/*
 		 * @see java.util.AbstractCollection#size()
 		 */
 		@Override
 		public final int size() {
 			return fImplementation.size();
 		}
 	}

 	/** The usage data */
 	private static final String DATA_USAGE= "us"; //$NON-NLS-1$

 	/** Maximal number of TTypes */
 	private static final int MAX_CACHE= 64;

 	/**
 	 * Returns the usage of the specified constraint variable.
 	 *
 	 * @param variable the constraint variable
 	 * @return the usage of the constraint variable (element type: <code>ITypeConstraint2</code>)
 	 */
 	public static Collection<ITypeConstraint2> getVariableUsage(final ConstraintVariable2 variable) {
 		final Object data= variable.getData(DATA_USAGE);
 		if (data == null) {
 			return Collections.emptyList();
 		} else if (data instanceof Collection) {
 			@SuppressWarnings("unchecked")
 			Collection<ITypeConstraint2> collection= (Collection<ITypeConstraint2>) data;
 			return Collections.unmodifiableCollection(collection);
 		} else {
 			return Collections.singletonList((ITypeConstraint2) data);
 		}
 	}

 	/**
 	 * Is the type represented by the specified binding a constrained type?
 	 *
 	 * @param binding the binding to check, or <code>null</code>
 	 * @return <code>true</code> if it is constrained, <code>false</code> otherwise
 	 */
 	public static boolean isConstrainedType(final ITypeBinding binding) {
 		return binding != null && !binding.isSynthetic() && !binding.isPrimitive();
 	}

 	/**
 	 * Sets the usage of the specified constraint variable.
 	 *
 	 * @param variable the constraint variable
 	 * @param constraint the type constraint
 	 */
 	public static void setVariableUsage(final ConstraintVariable2 variable, ITypeConstraint2 constraint) {
 		final Object data= variable.getData(DATA_USAGE);
 		if (data == null) {
 			variable.setData(DATA_USAGE, constraint);
 		} else if (data instanceof Collection) {
 			@SuppressWarnings("unchecked")
 			Collection<ITypeConstraint2> collection= (Collection<ITypeConstraint2>) data;
 			collection.add(constraint);
 		} else {
 			final Collection<Object> usage= new ArrayList<Object>(2);
 			usage.add(data);
 			usage.add(constraint);
 			variable.setData(DATA_USAGE, usage);
 		}
 	}

 	/** The cast variables (element type: <code>CastVariable2</code>) */
 	private final Collection<CastVariable2> fCastVariables= new ArrayList<CastVariable2>();

 	/** The compliance level */
 	private int fCompliance= 3;

 	/** The set of constraint variables (element type: <code>ConstraintVariable2</code>) */
 	private final HashedSet<ConstraintVariable2> fConstraintVariables= new HashedSet<ConstraintVariable2>();

 	/** The covariant type constraints (element type: <code>CovariantTypeConstraint</code>) */
 	private final Collection<ITypeConstraint2> fCovariantTypeConstraints= new ArrayList<ITypeConstraint2>();

 	/** The type environment to use */
 	private TypeEnvironment fEnvironment;

 	/** The subtype to replace */
 	private final TType fSubType;

 	/** The supertype as replacement */
 	private final TType fSuperType;

 	/** The TType cache */
 	private Map<String, TType> fTTypeCache= new LinkedHashMap<String, TType>(MAX_CACHE, 0.75f, true) {

 		private static final long serialVersionUID= 1L;

 		@Override
 		protected final boolean removeEldestEntry(Map.Entry<String, TType> entry) {
 			return size() > MAX_CACHE;
 		}
 	};

 	/** The set of type constraints (element type: <code>ITypeConstraint2</code>) */
 	private final Set<ITypeConstraint2> fTypeConstraints= new HashSet<ITypeConstraint2>();

 	/**
 	 * Creates a new super type constraints model.
 	 *
 	 * @param environment the type environment
 	 * @param subType the subtype to replace
 	 * @param superType the supertype replacement
 	 */
 	public SuperTypeConstraintsModel(final TypeEnvironment environment, TType subType, TType superType) {
 		fEnvironment= environment;
 		fSubType= subType;
 		fSuperType= superType;
 	}

 	/**
 	 * Gets called when the creation of the model begins.
 	 */
 	public final void beginCreation() {
 		// Do nothing right now
 	}

 	/**
 	 * Creates a cast variable.
 	 *
 	 * @param expression the cast expression
 	 * @param variable the associated constraint variable
 	 * @return the created cast variable
 	 */
 	public final ConstraintVariable2 createCastVariable(final CastExpression expression, final ConstraintVariable2 variable) {
 		ITypeBinding binding= expression.resolveTypeBinding();
 		if (binding.isArray())
 			binding= binding.getElementType();
 		if (isConstrainedType(binding)) {
 			final CastVariable2 result= new CastVariable2(createTType(binding), new CompilationUnitRange(RefactoringASTParser.getCompilationUnit(expression), expression), variable);
 			fCastVariables.add(result);
 			return result;
 		}
 		return null;
 	}

 	/**
 	 * Creates a conditional type constraint.
 	 *
 	 * @param expressionVariable the expression type constraint variable
 	 * @param thenVariable the then type constraint variable
 	 * @param elseVariable the else type constraint variable
 	 */
 	public final void createConditionalTypeConstraint(final ConstraintVariable2 expressionVariable, final ConstraintVariable2 thenVariable, final ConstraintVariable2 elseVariable) {
 		final ITypeConstraint2 constraint= new ConditionalTypeConstraint(expressionVariable, thenVariable, elseVariable);
 		if (!fTypeConstraints.contains(constraint)) {
 			fTypeConstraints.add(constraint);
 			setVariableUsage(expressionVariable, constraint);
 			setVariableUsage(thenVariable, constraint);
 			setVariableUsage(elseVariable, constraint);
 		}
 	}

 	/**
 	 * Creates a subtype constraint.
 	 *
 	 * @param descendant the descendant type constraint variable
 	 * @param ancestor the ancestor type constraint variable
 	 */
 	public final void createCovariantTypeConstraint(final ConstraintVariable2 descendant, final ConstraintVariable2 ancestor) {
 		final ITypeConstraint2 constraint= new CovariantTypeConstraint(descendant, ancestor);
 		if (!fTypeConstraints.contains(constraint)) {
 			fTypeConstraints.add(constraint);
 			fCovariantTypeConstraints.add(constraint);
 			setVariableUsage(descendant, constraint);
 			setVariableUsage(ancestor, constraint);
 		}
 	}

 	/**
 	 * Creates a declaring type variable.
 	 * <p>
 	 * A declaring type variable stands for a type where something has been declared.
 	 * </p>
 	 *
 	 * @param type the type binding
 	 * @return the created declaring type variable
 	 */
 	public final ConstraintVariable2 createDeclaringTypeVariable(ITypeBinding type) {
 		if (type.isArray())
 			type= type.getElementType();
 		type= type.getTypeDeclaration();
 		return fConstraintVariables.addExisting(new ImmutableTypeVariable2(createTType(type)));
 	}

 	/**
 	 * Creates an equality constraint.
 	 *
 	 * @param left the left typeconstraint variable
 	 * @param right the right typeconstraint variable
 	 */
 	public final void createEqualityConstraint(final ConstraintVariable2 left, final ConstraintVariable2 right) {
 		if (left != null && right != null) {
 			final TypeEquivalenceSet first= left.getTypeEquivalenceSet();
 			final TypeEquivalenceSet second= right.getTypeEquivalenceSet();
 			if (first == null) {
 				if (second == null) {
 					final TypeEquivalenceSet set= new TypeEquivalenceSet(left, right);
 					left.setTypeEquivalenceSet(set);
 					right.setTypeEquivalenceSet(set);
 				} else {
 					second.add(left);
 					left.setTypeEquivalenceSet(second);
 				}
 			} else {
 				if (second == null) {
 					first.add(right);
 					right.setTypeEquivalenceSet(first);
 				} else if (first == second)
 					return;
 				else {
 					final ConstraintVariable2[] variables= second.getContributingVariables();
 					first.addAll(variables);
 					for (int index= 0; index < variables.length; index++)
 						variables[index].setTypeEquivalenceSet(first);
 				}
 			}
 		}
 	}

 	/**
 	 * Creates an exception variable.
 	 *
 	 * @param name the name of the thrown exception
 	 * @return the created exception variable
 	 */
 	public final ConstraintVariable2 createExceptionVariable(final Name name) {
 		final ITypeBinding binding= name.resolveTypeBinding();
 		if (isConstrainedType(binding))
 			return fConstraintVariables.addExisting(new TypeVariable2(createTType(binding), new CompilationUnitRange(RefactoringASTParser.getCompilationUnit(name), name)));
 		return null;
 	}

 	/**
 	 * Creates an immutable type variable.
 	 *
 	 * @param type the type binding
 	 * @return the created plain type variable
 	 */
 	public final ConstraintVariable2 createImmutableTypeVariable(ITypeBinding type) {
 		if (type.isArray())
 			type= type.getElementType();
 		if (isConstrainedType(type))
 			return fConstraintVariables.addExisting(new ImmutableTypeVariable2(createTType(type)));
 		return null;
 	}

 	/**
 	 * Creates an independent type variable.
 	 * <p>
 	 * An independant type variable stands for an arbitrary type.
 	 * </p>
 	 *
 	 * @param type the type binding
 	 * @return the created independant type variable
 	 */
 	public final ConstraintVariable2 createIndependentTypeVariable(ITypeBinding type) {
 		if (type.isArray())
 			type= type.getElementType();
 		if (isConstrainedType(type))
 			return fConstraintVariables.addExisting(new IndependentTypeVariable2(createTType(type)));
 		return null;
 	}

 	/**
 	 * Creates a new method parameter variable.
 	 *
 	 * @param method the method binding
 	 * @param index the index of the parameter
 	 * @return the created method parameter variable
 	 */
 	public final ConstraintVariable2 createMethodParameterVariable(final IMethodBinding method, final int index) {
 		final ITypeBinding[] parameters= method.getParameterTypes();
 		if (parameters.length < 1)
 			return null;
 		ITypeBinding binding= parameters[Math.min(index, parameters.length - 1)];
 		if (binding.isArray())
 			binding= binding.getElementType();
 		if (isConstrainedType(binding)) {
 			ConstraintVariable2 variable= null;
 			final TType type= createTType(binding);
 			if (method.getDeclaringClass().isFromSource())
 				variable= new ParameterTypeVariable2(type, index, method.getMethodDeclaration());
 			else
 				variable= new ImmutableTypeVariable2(type);
 			return fConstraintVariables.addExisting(variable);
 		}
 		return null;
 	}

 	/**
 	 * Creates a new return type variable.
 	 *
 	 * @param method the method binding
 	 * @return the created return type variable
 	 */
 	public final ConstraintVariable2 createReturnTypeVariable(final IMethodBinding method) {
 		if (!method.isConstructor()) {
 			ITypeBinding binding= method.getReturnType();
 			if (binding != null && binding.isArray())
 				binding= binding.getElementType();
 			if (binding != null && isConstrainedType(binding)) {
 				ConstraintVariable2 variable= null;
 				final TType type= createTType(binding);
 				if (method.getDeclaringClass().isFromSource())
 					variable= new ReturnTypeVariable2(type, method);
 				else
 					variable= new ImmutableTypeVariable2(type);
 				return fConstraintVariables.addExisting(variable);
 			}
 		}
 		return null;
 	}

 	/**
 	 * Creates a subtype constraint.
 	 *
 	 * @param descendant the descendant type constraint variable
 	 * @param ancestor the ancestor type constraint variable
 	 */
 	public final void createSubtypeConstraint(final ConstraintVariable2 descendant, final ConstraintVariable2 ancestor) {
 		final ITypeConstraint2 constraint= new SubTypeConstraint2(descendant, ancestor);
 		if (!fTypeConstraints.contains(constraint)) {
 			fTypeConstraints.add(constraint);
 			setVariableUsage(descendant, constraint);
 			setVariableUsage(ancestor, constraint);
 		}
 	}

 	/**
 	 * Creates a new TType for the corresponding binding.
 	 *
 	 * @param binding The type binding
 	 * @return The corresponding TType
 	 */
 	public final TType createTType(final ITypeBinding binding) {
 		final String key= binding.getKey();
 		final TType cached= fTTypeCache.get(key);
 		if (cached != null)
 			return cached;
 		final TType type= fEnvironment.create(binding);
 		fTTypeCache.put(key, type);
 		return type;
 	}

 	/**
 	 * Creates a type variable.
 	 *
 	 * @param type the type binding
 	 * @param range the compilation unit range
 	 * @return the created type variable
 	 */
 	public final ConstraintVariable2 createTypeVariable(ITypeBinding type, final CompilationUnitRange range) {
 		if (type.isArray())
 			type= type.getElementType();
 		if (isConstrainedType(type))
 			return fConstraintVariables.addExisting(new TypeVariable2(createTType(type), range));
 		return null;
 	}

 	/**
 	 * Creates a type variable.
 	 *
 	 * @param type the type
 	 * @return the created type variable
 	 */
 	public final ConstraintVariable2 createTypeVariable(final Type type) {
 		ITypeBinding binding= type.resolveBinding();
 		if (binding != null) {
 			if (binding.isArray())
 				binding= binding.getElementType();
 			if (isConstrainedType(binding))
 				return fConstraintVariables.addExisting(new TypeVariable2(createTType(binding), new CompilationUnitRange(RefactoringASTParser.getCompilationUnit(type), type)));
 		}
 		return null;
 	}

 	/**
 	 * Creates a variable type variable.
 	 *
 	 * @param binding the variable binding
 	 * @return the created variable variable
 	 */
 	public final ConstraintVariable2 createVariableVariable(final IVariableBinding binding) {
 		ITypeBinding type= binding.getType();
 		if (type.isArray())
 			type= type.getElementType();
 		if (isConstrainedType(type)) {
 			ConstraintVariable2 variable= null;
 			final IVariableBinding declaration= binding.getVariableDeclaration();
 			if (declaration.isField()) {
 				final ITypeBinding declaring= declaration.getDeclaringClass();
 				if (!declaring.isFromSource())
 					variable= new ImmutableTypeVariable2(createTType(type));
 			} else {
 				final IMethodBinding declaring= declaration.getDeclaringMethod();
 				if (declaring != null && !declaring.getDeclaringClass().isFromSource())
 					variable= new ImmutableTypeVariable2(createTType(type));
 			}
 			if (variable == null)
 				variable= new VariableVariable2(createTType(type), declaration);
 			return fConstraintVariables.addExisting(variable);
 		}
 		return null;
 	}

 	/**
 	 * Gets called when the creation of the model ends.
 	 */
 	public final void endCreation() {
 		fEnvironment= null;
 		fTTypeCache= null;
 	}

 	/**
 	 * Returns the cast variables of this model.
 	 *
 	 * @return the cast variables (element type: <code>CastVariable2</code>)
 	 */
 	public final Collection<CastVariable2> getCastVariables() {
 		return Collections.unmodifiableCollection(fCastVariables);
 	}

 	/**
 	 * Returns the compliance level to use.
 	 *
 	 * @return the compliance level
 	 */
 	public final int getCompliance() {
 		return fCompliance;
 	}

 	/**
 	 * Returns the constraint variables of this model.
 	 *
 	 * @return the constraint variables (element type: <code>ConstraintVariable2</code>)
 	 */
 	public final Collection<ConstraintVariable2> getConstraintVariables() {
 		return Collections.unmodifiableCollection(fConstraintVariables);
 	}

 	/**
 	 * Returns the subtype to be replaced.
 	 *
 	 * @return the subtype to be replaced
 	 */
 	public final TType getSubType() {
 		return fSubType;
 	}

 	/**
 	 * Returns the supertype as replacement.
 	 *
 	 * @return the supertype as replacement
 	 */
 	public final TType getSuperType() {
 		return fSuperType;
 	}

 	/**
 	 * Returns the type constraints of this model.
 	 *
 	 * @return the type constraints (element type: <code>ITypeConstraint2</code>)
 	 */
 	public final Collection<ITypeConstraint2> getTypeConstraints() {
 		return Collections.unmodifiableCollection(fTypeConstraints);
 	}

 	/**
 	 * Sets the compliance level to use.
 	 *
 	 * @param level the compliance level to use. The argument must be one of the <code>AST.JLSx</code> constants.
 	 */
 	public final void setCompliance(final int level) {
 		fCompliance= level;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2011 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.jdt.internal.corext.refactoring.structure.constraints;

	import java.util.AbstractSet;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.LinkedHashMap;
	import java.util.Map;
	import java.util.Set;

	import org.eclipse.jdt.core.dom.CastExpression;
	import org.eclipse.jdt.core.dom.IMethodBinding;
	import org.eclipse.jdt.core.dom.ITypeBinding;
	import org.eclipse.jdt.core.dom.IVariableBinding;
	import org.eclipse.jdt.core.dom.Name;
	import org.eclipse.jdt.core.dom.Type;

	import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.CompilationUnitRange;
	import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.TType;
	import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.TypeEnvironment;
	import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.CastVariable2;
	import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.ConstraintVariable2;
	import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.ITypeConstraint2;
	import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.ImmutableTypeVariable2;
	import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.IndependentTypeVariable2;
	import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.ParameterTypeVariable2;
	import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.ReturnTypeVariable2;
	import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.SubTypeConstraint2;
	import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TypeEquivalenceSet;
	import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TypeVariable2;
	import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.VariableVariable2;
	import org.eclipse.jdt.internal.corext.refactoring.util.RefactoringASTParser;


	/**
	* Type constraints model to hold all type constraints to replace type occurrences by a given supertype.
	*
	* @since 3.1
	*/
	public final class SuperTypeConstraintsModel {

	/** Customized implementation of a hash set
	* @param <E> the element type */
	private static class HashedSet<E> extends AbstractSet<E> {

	/** The backing hash map */
	private final Map<E, E> fImplementation= new HashMap<E, E>();

	/*
	* @see java.util.AbstractCollection#add(java.lang.Object)
	*/
	@Override
	public final boolean add(final E object) {
	return fImplementation.put(object, object) == null;
	}

	/**
	* Attempts to add the specified object to this set.
	*
	* @param object the object to add
	* @return An already existing object considered equal to the specified one, or the newly added object
	*/
	public final E addExisting(final E object) {
	final E result= fImplementation.get(object);
	if (result != null)
	return result;
	fImplementation.put(object, object);
	return object;
	}

	/*
	* @see java.util.AbstractCollection#clear()
	*/
	@Override
	public final void clear() {
	fImplementation.clear();
	}

	/*
	* @see java.util.AbstractCollection#contains(java.lang.Object)
	*/
	@Override
	public final boolean contains(final Object object) {
	return fImplementation.containsKey(object);
	}

	/*
	* @see java.util.AbstractCollection#isEmpty()
	*/
	@Override
	public final boolean isEmpty() {
	return fImplementation.isEmpty();
	}

	/*
	* @see java.util.AbstractCollection#iterator()
	*/
	@Override
	public final Iterator<E> iterator() {
	return fImplementation.keySet().iterator();
	}

	/*
	* @see java.util.AbstractCollection#remove(java.lang.Object)
	*/
	@Override
	public final boolean remove(final Object object) {
	return fImplementation.remove(object) == object;
	}

	/*
	* @see java.util.AbstractCollection#size()
	*/
	@Override
	public final int size() {
	return fImplementation.size();
	}
	}

	/** The usage data */
	private static final String DATA_USAGE= "us"; //$NON-NLS-1$

	/** Maximal number of TTypes */
	private static final int MAX_CACHE= 64;

	/**
	* Returns the usage of the specified constraint variable.
	*
	* @param variable the constraint variable
	* @return the usage of the constraint variable (element type: <code>ITypeConstraint2</code>)
	*/
	public static Collection<ITypeConstraint2> getVariableUsage(final ConstraintVariable2 variable) {
	final Object data= variable.getData(DATA_USAGE);
	if (data == null) {
	return Collections.emptyList();
	} else if (data instanceof Collection) {
	@SuppressWarnings("unchecked")
	Collection<ITypeConstraint2> collection= (Collection<ITypeConstraint2>) data;
	return Collections.unmodifiableCollection(collection);
	} else {
	return Collections.singletonList((ITypeConstraint2) data);
	}
	}

	/**
	* Is the type represented by the specified binding a constrained type?
	*
	* @param binding the binding to check, or <code>null</code>
	* @return <code>true</code> if it is constrained, <code>false</code> otherwise
	*/
	public static boolean isConstrainedType(final ITypeBinding binding) {
	return binding != null && !binding.isSynthetic() && !binding.isPrimitive();
	}

	/**
	* Sets the usage of the specified constraint variable.
	*
	* @param variable the constraint variable
	* @param constraint the type constraint
	*/
	public static void setVariableUsage(final ConstraintVariable2 variable, ITypeConstraint2 constraint) {
	final Object data= variable.getData(DATA_USAGE);
	if (data == null) {
	variable.setData(DATA_USAGE, constraint);
	} else if (data instanceof Collection) {
	@SuppressWarnings("unchecked")
	Collection<ITypeConstraint2> collection= (Collection<ITypeConstraint2>) data;
	collection.add(constraint);
	} else {
	final Collection<Object> usage= new ArrayList<Object>(2);
	usage.add(data);
	usage.add(constraint);
	variable.setData(DATA_USAGE, usage);
	}
	}

	/** The cast variables (element type: <code>CastVariable2</code>) */
	private final Collection<CastVariable2> fCastVariables= new ArrayList<CastVariable2>();

	/** The compliance level */
	private int fCompliance= 3;

	/** The set of constraint variables (element type: <code>ConstraintVariable2</code>) */
	private final HashedSet<ConstraintVariable2> fConstraintVariables= new HashedSet<ConstraintVariable2>();

	/** The covariant type constraints (element type: <code>CovariantTypeConstraint</code>) */
	private final Collection<ITypeConstraint2> fCovariantTypeConstraints= new ArrayList<ITypeConstraint2>();

	/** The type environment to use */
	private TypeEnvironment fEnvironment;

	/** The subtype to replace */
	private final TType fSubType;

	/** The supertype as replacement */
	private final TType fSuperType;

	/** The TType cache */
	private Map<String, TType> fTTypeCache= new LinkedHashMap<String, TType>(MAX_CACHE, 0.75f, true) {

	private static final long serialVersionUID= 1L;

	@Override
	protected final boolean removeEldestEntry(Map.Entry<String, TType> entry) {
	return size() > MAX_CACHE;
	}
	};

	/** The set of type constraints (element type: <code>ITypeConstraint2</code>) */
	private final Set<ITypeConstraint2> fTypeConstraints= new HashSet<ITypeConstraint2>();

	/**
	* Creates a new super type constraints model.
	*
	* @param environment the type environment
	* @param subType the subtype to replace
	* @param superType the supertype replacement
	*/
	public SuperTypeConstraintsModel(final TypeEnvironment environment, TType subType, TType superType) {
	fEnvironment= environment;
	fSubType= subType;
	fSuperType= superType;
	}

	/**
	* Gets called when the creation of the model begins.
	*/
	public final void beginCreation() {
	// Do nothing right now
	}

	/**
	* Creates a cast variable.
	*
	* @param expression the cast expression
	* @param variable the associated constraint variable
	* @return the created cast variable
	*/
	public final ConstraintVariable2 createCastVariable(final CastExpression expression, final ConstraintVariable2 variable) {
	ITypeBinding binding= expression.resolveTypeBinding();
	if (binding.isArray())
	binding= binding.getElementType();
	if (isConstrainedType(binding)) {
	final CastVariable2 result= new CastVariable2(createTType(binding), new CompilationUnitRange(RefactoringASTParser.getCompilationUnit(expression), expression), variable);
	fCastVariables.add(result);
	return result;
	}
	return null;
	}

	/**
	* Creates a conditional type constraint.
	*
	* @param expressionVariable the expression type constraint variable
	* @param thenVariable the then type constraint variable
	* @param elseVariable the else type constraint variable
	*/
	public final void createConditionalTypeConstraint(final ConstraintVariable2 expressionVariable, final ConstraintVariable2 thenVariable, final ConstraintVariable2 elseVariable) {
	final ITypeConstraint2 constraint= new ConditionalTypeConstraint(expressionVariable, thenVariable, elseVariable);
	if (!fTypeConstraints.contains(constraint)) {
	fTypeConstraints.add(constraint);
	setVariableUsage(expressionVariable, constraint);
	setVariableUsage(thenVariable, constraint);
	setVariableUsage(elseVariable, constraint);
	}
	}

	/**
	* Creates a subtype constraint.
	*
	* @param descendant the descendant type constraint variable
	* @param ancestor the ancestor type constraint variable
	*/
	public final void createCovariantTypeConstraint(final ConstraintVariable2 descendant, final ConstraintVariable2 ancestor) {
	final ITypeConstraint2 constraint= new CovariantTypeConstraint(descendant, ancestor);
	if (!fTypeConstraints.contains(constraint)) {
	fTypeConstraints.add(constraint);
	fCovariantTypeConstraints.add(constraint);
	setVariableUsage(descendant, constraint);
	setVariableUsage(ancestor, constraint);
	}
	}

	/**
	* Creates a declaring type variable.
	* <p>
	* A declaring type variable stands for a type where something has been declared.
	* </p>
	*
	* @param type the type binding
	* @return the created declaring type variable
	*/
	public final ConstraintVariable2 createDeclaringTypeVariable(ITypeBinding type) {
	if (type.isArray())
	type= type.getElementType();
	type= type.getTypeDeclaration();
	return fConstraintVariables.addExisting(new ImmutableTypeVariable2(createTType(type)));
	}

	/**
	* Creates an equality constraint.
	*
	* @param left the left typeconstraint variable
	* @param right the right typeconstraint variable
	*/
	public final void createEqualityConstraint(final ConstraintVariable2 left, final ConstraintVariable2 right) {
	if (left != null && right != null) {
	final TypeEquivalenceSet first= left.getTypeEquivalenceSet();
	final TypeEquivalenceSet second= right.getTypeEquivalenceSet();
	if (first == null) {
	if (second == null) {
	final TypeEquivalenceSet set= new TypeEquivalenceSet(left, right);
	left.setTypeEquivalenceSet(set);
	right.setTypeEquivalenceSet(set);
	} else {
	second.add(left);
	left.setTypeEquivalenceSet(second);
	}
	} else {
	if (second == null) {
	first.add(right);
	right.setTypeEquivalenceSet(first);
	} else if (first == second)
	return;
	else {
	final ConstraintVariable2[] variables= second.getContributingVariables();
	first.addAll(variables);
	for (int index= 0; index < variables.length; index++)
	variables[index].setTypeEquivalenceSet(first);
	}
	}
	}
	}

	/**
	* Creates an exception variable.
	*
	* @param name the name of the thrown exception
	* @return the created exception variable
	*/
	public final ConstraintVariable2 createExceptionVariable(final Name name) {
	final ITypeBinding binding= name.resolveTypeBinding();
	if (isConstrainedType(binding))
	return fConstraintVariables.addExisting(new TypeVariable2(createTType(binding), new CompilationUnitRange(RefactoringASTParser.getCompilationUnit(name), name)));
	return null;
	}

	/**
	* Creates an immutable type variable.
	*
	* @param type the type binding
	* @return the created plain type variable
	*/
	public final ConstraintVariable2 createImmutableTypeVariable(ITypeBinding type) {
	if (type.isArray())
	type= type.getElementType();
	if (isConstrainedType(type))
	return fConstraintVariables.addExisting(new ImmutableTypeVariable2(createTType(type)));
	return null;
	}

	/**
	* Creates an independent type variable.
	* <p>
	* An independant type variable stands for an arbitrary type.
	* </p>
	*
	* @param type the type binding
	* @return the created independant type variable
	*/
	public final ConstraintVariable2 createIndependentTypeVariable(ITypeBinding type) {
	if (type.isArray())
	type= type.getElementType();
	if (isConstrainedType(type))
	return fConstraintVariables.addExisting(new IndependentTypeVariable2(createTType(type)));
	return null;
	}

	/**
	* Creates a new method parameter variable.
	*
	* @param method the method binding
	* @param index the index of the parameter
	* @return the created method parameter variable
	*/
	public final ConstraintVariable2 createMethodParameterVariable(final IMethodBinding method, final int index) {
	final ITypeBinding[] parameters= method.getParameterTypes();
	if (parameters.length < 1)
	return null;
	ITypeBinding binding= parameters[Math.min(index, parameters.length - 1)];
	if (binding.isArray())
	binding= binding.getElementType();
	if (isConstrainedType(binding)) {
	ConstraintVariable2 variable= null;
	final TType type= createTType(binding);
	if (method.getDeclaringClass().isFromSource())
	variable= new ParameterTypeVariable2(type, index, method.getMethodDeclaration());
	else
	variable= new ImmutableTypeVariable2(type);
	return fConstraintVariables.addExisting(variable);
	}
	return null;
	}

	/**
	* Creates a new return type variable.
	*
	* @param method the method binding
	* @return the created return type variable
	*/
	public final ConstraintVariable2 createReturnTypeVariable(final IMethodBinding method) {
	if (!method.isConstructor()) {
	ITypeBinding binding= method.getReturnType();
	if (binding != null && binding.isArray())
	binding= binding.getElementType();
	if (binding != null && isConstrainedType(binding)) {
	ConstraintVariable2 variable= null;
	final TType type= createTType(binding);
	if (method.getDeclaringClass().isFromSource())
	variable= new ReturnTypeVariable2(type, method);
	else
	variable= new ImmutableTypeVariable2(type);
	return fConstraintVariables.addExisting(variable);
	}
	}
	return null;
	}

	/**
	* Creates a subtype constraint.
	*
	* @param descendant the descendant type constraint variable
	* @param ancestor the ancestor type constraint variable
	*/
	public final void createSubtypeConstraint(final ConstraintVariable2 descendant, final ConstraintVariable2 ancestor) {
	final ITypeConstraint2 constraint= new SubTypeConstraint2(descendant, ancestor);
	if (!fTypeConstraints.contains(constraint)) {
	fTypeConstraints.add(constraint);
	setVariableUsage(descendant, constraint);
	setVariableUsage(ancestor, constraint);
	}
	}

	/**
	* Creates a new TType for the corresponding binding.
	*
	* @param binding The type binding
	* @return The corresponding TType
	*/
	public final TType createTType(final ITypeBinding binding) {
	final String key= binding.getKey();
	final TType cached= fTTypeCache.get(key);
	if (cached != null)
	return cached;
	final TType type= fEnvironment.create(binding);
	fTTypeCache.put(key, type);
	return type;
	}

	/**
	* Creates a type variable.
	*
	* @param type the type binding
	* @param range the compilation unit range
	* @return the created type variable
	*/
	public final ConstraintVariable2 createTypeVariable(ITypeBinding type, final CompilationUnitRange range) {
	if (type.isArray())
	type= type.getElementType();
	if (isConstrainedType(type))
	return fConstraintVariables.addExisting(new TypeVariable2(createTType(type), range));
	return null;
	}

	/**
	* Creates a type variable.
	*
	* @param type the type
	* @return the created type variable
	*/
	public final ConstraintVariable2 createTypeVariable(final Type type) {
	ITypeBinding binding= type.resolveBinding();
	if (binding != null) {
	if (binding.isArray())
	binding= binding.getElementType();
	if (isConstrainedType(binding))
	return fConstraintVariables.addExisting(new TypeVariable2(createTType(binding), new CompilationUnitRange(RefactoringASTParser.getCompilationUnit(type), type)));
	}
	return null;
	}

	/**
	* Creates a variable type variable.
	*
	* @param binding the variable binding
	* @return the created variable variable
	*/
	public final ConstraintVariable2 createVariableVariable(final IVariableBinding binding) {
	ITypeBinding type= binding.getType();
	if (type.isArray())
	type= type.getElementType();
	if (isConstrainedType(type)) {
	ConstraintVariable2 variable= null;
	final IVariableBinding declaration= binding.getVariableDeclaration();
	if (declaration.isField()) {
	final ITypeBinding declaring= declaration.getDeclaringClass();
	if (!declaring.isFromSource())
	variable= new ImmutableTypeVariable2(createTType(type));
	} else {
	final IMethodBinding declaring= declaration.getDeclaringMethod();
	if (declaring != null && !declaring.getDeclaringClass().isFromSource())
	variable= new ImmutableTypeVariable2(createTType(type));
	}
	if (variable == null)
	variable= new VariableVariable2(createTType(type), declaration);
	return fConstraintVariables.addExisting(variable);
	}
	return null;
	}

	/**
	* Gets called when the creation of the model ends.
	*/
	public final void endCreation() {
	fEnvironment= null;
	fTTypeCache= null;
	}

	/**
	* Returns the cast variables of this model.
	*
	* @return the cast variables (element type: <code>CastVariable2</code>)
	*/
	public final Collection<CastVariable2> getCastVariables() {
	return Collections.unmodifiableCollection(fCastVariables);
	}

	/**
	* Returns the compliance level to use.
	*
	* @return the compliance level
	*/
	public final int getCompliance() {
	return fCompliance;
	}

	/**
	* Returns the constraint variables of this model.
	*
	* @return the constraint variables (element type: <code>ConstraintVariable2</code>)
	*/
	public final Collection<ConstraintVariable2> getConstraintVariables() {
	return Collections.unmodifiableCollection(fConstraintVariables);
	}

	/**
	* Returns the subtype to be replaced.
	*
	* @return the subtype to be replaced
	*/
	public final TType getSubType() {
	return fSubType;
	}

	/**
	* Returns the supertype as replacement.
	*
	* @return the supertype as replacement
	*/
	public final TType getSuperType() {
	return fSuperType;
	}

	/**
	* Returns the type constraints of this model.
	*
	* @return the type constraints (element type: <code>ITypeConstraint2</code>)
	*/
	public final Collection<ITypeConstraint2> getTypeConstraints() {
	return Collections.unmodifiableCollection(fTypeConstraints);
	}

	/**
	* Sets the compliance level to use.
	*
	* @param level the compliance level to use. The argument must be one of the <code>AST.JLSx</code> constants.
	*/
	public final void setCompliance(final int level) {
	fCompliance= level;
	}
	}