UnionType.cs

Go to the documentation of this file.

// -------------------------------------------------------------------------- 
// Project rROTOR                                                             
// -------------------------------------------------------------------------- 
// File: UnionType.cs                                                      
// Authors: Francisco Ortin - francisco.ortin@gmail.com                       
// Description:                                                               
//    Represents a disjunction set type.                                      
//    Inheritance: TypeExpression.                                            
//    Implements Composite pattern [Composite].                               
// -------------------------------------------------------------------------- 
// Create date: 05-04-2007                                                    
// Modification date: 05-04-2007                                              
//visto
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;

using AST;
using ErrorManagement;
using Tools;
using TypeSystem.Constraints;
using TypeSystem.Operations;

namespace TypeSystem {
    public class UnionType : TypeExpression {
      
        #region Fields
        private List<TypeExpression> typeSet = new List<TypeExpression>();
        #endregion

        #region Properties

        public int Count {
            get { return this.typeSet.Count; }
        }

        public IList<TypeExpression> TypeSet {
            get { return this.typeSet; }
        }

        #endregion

        #region Constructor

        public UnionType() { }
        public UnionType(TypeExpression te) {
            this.AddType(te);
            this.BuildFullName();
        }
        #endregion

        #region AddType
        public bool AddType(TypeExpression type) {
            bool added = true;
            UnionType union = type as UnionType;
            if (union != null) {
                foreach (TypeExpression t in union.typeSet)
                    added = this.AddType(t) && added;
                this.ValidTypeExpression = false;
                return added;
            }
            TypeExpression existingType = typeSet.Find(type.Equals);
            if (existingType == null) {
                this.typeSet.Add(type);
                this.ValidTypeExpression = false;
                return true;
            }
            return false;
        }
        #endregion

        #region ToString()

        public override string BuildTypeExpressionString(int depthLevel) {
            if (this.ValidTypeExpression) return this.typeExpression;
            if (depthLevel <= 0) return this.FullName;

            StringBuilder aux = new StringBuilder();
            aux.Append("\\/(");
            for (int i = 0; i < this.typeSet.Count; i++) {
                aux.AppendFormat("{0}", this.typeSet[i].BuildTypeExpressionString(depthLevel - 1));
                if (i < this.typeSet.Count - 1)
                    aux.AppendFormat(" ,");
            }
            aux.Append(")");
            this.typeExpression = aux.ToString();
            this.ValidTypeExpression = true;
            return this.typeExpression;
        }
        #endregion

        #region BuildFullName()
        public override void BuildFullName() {
            StringBuilder aux = new StringBuilder();
            aux.Append("\\/(");
            for (int i = 0; i < this.typeSet.Count; i++) {
                aux.AppendFormat("{0}", this.typeSet[i].FullName);
                if (i < this.typeSet.Count - 1)
                    aux.AppendFormat(" ,");
            }
            aux.Append(")");
            this.fullName = aux.ToString();
        }
        #endregion

        // WriteType inference

        #region Dispatcher
        public override object AcceptOperation(TypeSystemOperation op, object arg) { return op.Exec(this, arg); }
        #endregion

        #region Assignment ANULADA
        //public override TypeExpression Assignment(TypeExpression operand, AssignmentOperator op, MethodType methodAnalyzed, SortOfUnification unification, TypeExpression actualImplicitObject, Location location) {
        //    // * If the unification is incremental, we must add it to the union typeset
        //    if (unification == SortOfUnification.Incremental) {
        //        this.typeSet.Add(operand);
        //        return this;
        //    }
        //    foreach (TypeExpression type in this.typeSet)
        //        if (operand.PromotionLevel(type) == -1) {
        //            ErrorManager.Instance.NotifyError(new AssignmentError(operand.FullName, this.fullName, location));
        //            return null;
        //        }
        //    return this;
        //}
        #endregion

        #region Equivalent() ANULADA
        //public override bool Equivalent(TypeExpression typeParam) {
        //    foreach (TypeExpression type in this.typeSet)
        //        if (!type.Equivalent(typeParam))
        //            return false;
        //    return true;
        //}
        #endregion

        #region Dot() ANULADA
        //public override TypeExpression Dot(string field, MethodType methodAnalyzed, IList<TypeExpression> previousDot, Location loc) {
        //    // * Infinite loop detection
        //    if (previousDot.Contains(this))
        //        return new UnionType();
        //    previousDot.Add(this);

        //    // * If all the types in typeset generate a constraint, we simply generate one constraint using the whole union type
        //    if (this.IsFreshVariable() && methodAnalyzed != null) {
        //        // * A constraint is added to the method analyzed
        //        DotConstraint constraint = new DotConstraint(this, field, loc);
        //        methodAnalyzed.AddConstraint(constraint);
        //        return constraint.ReturnType;
        //    }
        //    TypeExpression returnType = null;
        //    foreach (TypeExpression type in this.typeSet) {
        //        TypeExpression ret;
        //        if (!this.IsDynamic) {
        //            // * Static Behaviour: All the types must accept the attribute access
        //            ret = type.Dot(field, methodAnalyzed, previousDot, loc);
        //            if (ret == null) {
        //                return null;
        //            }
        //        }
        //        else
        //            // * Dynamic Behaviour: Only one type must accept the attribute access
        //            ret = type.Dot(field, previousDot);
        //        if (ret != null)
        //            returnType = UnionType.collect(returnType, ret);
        //    }
        //    // * If it is a dynamic union, one type must accept the attribute access
        //    if (returnType == null)
        //        ErrorManager.Instance.NotifyError(new NoTypeHasMember(this.FullName, field, loc));
        //    return returnType;
        //}
        //public override TypeExpression Dot(string memberName, IList<TypeExpression> previousDot) {
        //    // * Infinite loop detection
        //    if (previousDot.Contains(this))
        //        return null;
        //    previousDot.Add(this);

        //    TypeExpression returnType = null;
        //    foreach (TypeExpression type in this.typeSet) {
        //        TypeExpression ret = type.Dot(memberName, previousDot);
        //        if (ret == null && !this.isDynamic)
        //            return null;
        //        if (ret != null)
        //            returnType = UnionType.collect(returnType, ret);
        //    }
        //    return returnType;
        //}
        #endregion

        #region Bracket() ANULADA
        //public override TypeExpression Bracket(TypeExpression index, MethodType methodAnalyzed, bool showErrorMessage, Location loc) {
        //    // * If all the types in typeset generate a constraint, we simply generate one constraint using the whole union type
        //    if (this.IsFreshVariable() && methodAnalyzed != null) {
        //        // * A constraint is added to the method analyzed
        //        SquareBracketConstraint constraint = new SquareBracketConstraint(this, index, loc);
        //        methodAnalyzed.AddConstraint(constraint);
        //        return constraint.ReturnType;
        //    }
        //    TypeExpression returnType = null;
        //    foreach (TypeExpression type in this.typeSet) {
        //        TypeExpression ret = type.Bracket(index, methodAnalyzed, !this.IsDynamic && showErrorMessage, loc);
        //        if (ret == null && !this.IsDynamic)
        //            return null;
        //        if (ret != null)
        //            returnType = UnionType.collect(returnType, ret);
        //    }
        //    return returnType;
        //}
        #endregion

        #region Parenthesis() ANULADA
        //public override TypeExpression Parenthesis(TypeExpression actualImplicitObject, TypeExpression[] arguments, MethodType methodAnalyzed,
        //                    SortOfUnification activeSortOfUnification, Location loc) {
        //    // * If all the types in typeset generate a constraint, we simply generate one constraint using the whole union type
        //    if (this.IsFreshVariable() && methodAnalyzed != null) {
        //        // * A constraint is added to the method analyzed
        //        ParenthesisConstraint constraint = new ParenthesisConstraint(this, actualImplicitObject, arguments, activeSortOfUnification, loc);
        //        methodAnalyzed.AddConstraint(constraint);
        //        return constraint.ReturnType;
        //    }
        //    TypeExpression returnType = null;
        //    foreach (TypeExpression type in this.typeSet) {
        //        TypeExpression ret = type.Parenthesis(actualImplicitObject, arguments, methodAnalyzed, activeSortOfUnification, loc);
        //        if (ret == null && this.isDynamic)
        //            return null;
        //        returnType = UnionType.collect(returnType, ret);
        //    }
        //    return returnType;
        //}
        #endregion

        #region Arithmetic() ANULADA
        /*
        public override TypeExpression Arithmetic(TypeExpression operand, Enum op, MethodType methodAnalyzed, bool showErrorMessage, Location loc) {
            // * If all the types in typeset generate a constraint, we simply generate one constraint using the whole union type
            if (this.IsFreshVariable() && methodAnalyzed != null) {
                // * A constraint is added to the method analyzed
                ArithmeticConstraint constraint = new ArithmeticConstraint(this, operand, op, loc);
                methodAnalyzed.AddConstraint(constraint);
                return constraint.ReturnType;
            }
            TypeExpression returnType = null;
            foreach (TypeExpression type in this.typeSet) {
                TypeExpression ret = type.Arithmetic(operand, op, methodAnalyzed, !this.IsDynamic && showErrorMessage, loc);
                if (ret == null && !this.IsDynamic)
                    return null;
                if (ret != null)
                    returnType = UnionType.collect(returnType, ret);
            }
            // * If there has been some errors, they have not been shown because the type is dynamic, we show it
            if (showErrorMessage && this.IsDynamic && returnType == null)
                ErrorManager.Instance.NotifyError(new NoTypeAcceptsOperation(this.FullName, op.ToString(), operand.FullName, loc));
            return returnType;
        }
        */
        /* ANULADA
        public override TypeExpression Arithmetic(UnaryOperator op, MethodType methodAnalyzed, bool showErrorMessage, Location loc) {
            // * If all the types in typeset generate a constraint, we simply generate one constraint using the whole union type
            if (this.IsFreshVariable() && methodAnalyzed != null) {
                // * A constraint is added to the method analyzed
                ArithmeticConstraint constraint = new ArithmeticConstraint(this, op, loc);
                methodAnalyzed.AddConstraint(constraint);
                return constraint.ReturnType;
            }
            TypeExpression returnType = null;
            foreach (TypeExpression type in this.typeSet) {
                TypeExpression ret = type.Arithmetic(op, methodAnalyzed, !this.IsDynamic && showErrorMessage, loc);
                if (ret == null && !this.IsDynamic)
                    return null;
                if (ret != null)
                    returnType = UnionType.collect(returnType, ret);
            }
            // * If there has been some errors, they have not been shown because the type is dynamic, we show it
            if (showErrorMessage && this.IsDynamic && returnType == null)
                ErrorManager.Instance.NotifyError(new NoTypeAcceptsOperation(this.FullName, op.ToString(), loc));
            return returnType;
        } */
        #endregion

        #region Relational()ANULADA
        /*
        public override TypeExpression Relational(TypeExpression operand, RelationalOperator op, MethodType methodAnalyzed, bool showErrorMessage, Location loc) {
            // * If all the types in typeset generate a constraint, we simply generate one constraint using the whole union type
            if (this.IsFreshVariable() && methodAnalyzed != null) {
                // * A constraint is added to the method analyzed
                RelationalConstraint constraint = new RelationalConstraint(this, operand, op, loc);
                methodAnalyzed.AddConstraint(constraint);
                return constraint.ReturnType;
            }
            bool oneCorrectType = false;
            foreach (TypeExpression type in this.typeSet) {
                TypeExpression ret = type.Relational(operand, op, methodAnalyzed, !this.IsDynamic && showErrorMessage, loc);
                if (ret == null && !this.IsDynamic)
                    return null;
                if (ret != null)
                    oneCorrectType = true;
            }
            // * If there has been some errors, they have not been shown because the type is dynamic, we show it
            if (showErrorMessage && this.IsDynamic && !oneCorrectType)
                ErrorManager.Instance.NotifyError(new NoTypeAcceptsOperation(this.FullName, op.ToString(), operand.FullName, loc));
            return BoolType.Instance;
        }*/

        #endregion

        // WriteType Promotion

        #region PromotionLevel() ANULADA
        //public override int PromotionLevel(TypeExpression superType) {
        //    // * Checks recursion
        //    if (recursivePromotionLevelDetection.Contains(this))
        //        return 0;
        //    recursivePromotionLevelDetection.Add(this);
        //    // * Static Behaviour: Takes the addition of all the promotion level
        //    // * Dynamic Behaviour: Takes the addition of all the promotion level
        //    int promotionLevel = this.IsDynamic ? Int32.MaxValue : 0;
        //    foreach (TypeExpression subType in this.typeSet) {
        //        int aux = subType.PromotionLevel(superType);
        //        if (this.IsDynamic && aux != -1) {
        //            // * Dynamic
        //            promotionLevel = Math.Min(promotionLevel, aux);
        //            if (promotionLevel == 0)
        //                break;
        //        }
        //        if (!this.IsDynamic) {
        //            // * Static
        //            if (aux == -1) {
        //                promotionLevel = -1;
        //                break;
        //            }
        //            promotionLevel += aux;
        //        }
        //    }
        //    if (this.IsDynamic && promotionLevel == Int32.MaxValue)
        //        // * No promotion at all
        //        promotionLevel = -1;
        //    // * Clears the loop detection for futures method calls
        //    recursivePromotionLevelDetection.Clear();
        //    return promotionLevel;
        //}
        //private static IList<UnionType> recursivePromotionLevelDetection = new List<UnionType>();
        #endregion

        #region Promotion()
        //public override TypeExpression Promotion(TypeExpression type, MethodType methodAnalyzed, Location loc) {
        //    return this.Promotion(type, AssignmentOperator.Assign, methodAnalyzed, loc);
        //}
        //public override TypeExpression Promotion(TypeExpression type, Enum op, MethodType methodAnalyzed, Location loc) {
        //    return this.InternalPromotion(type, op, methodAnalyzed, loc);
        //}
        //private TypeExpression InternalPromotion(TypeExpression superType, Enum op, MethodType methodAnalyzed, Location loc) {
        //    if (this.IsFreshVariable() && methodAnalyzed != null) {
        //        // * A constraint is added to the method analyzed
        //        PromotionConstraint constraint = new PromotionConstraint(this, superType, op, loc);
        //        methodAnalyzed.AddConstraint(constraint);
        //        return superType;
        //    }
        //    // * Static Behaviour: All the types in typeset must promote 
        //    // * Dynamic Behaviour: One of the types in typeset must promote
        //    int aux = 0;
        //    UnionType dynamicUnionType = new UnionType();
        //    dynamicUnionType.isDynamic = true;
        //    foreach (TypeExpression subType in this.typeSet) {
        //        if (this.IsDynamic) {
        //            // * Dynamic
        //            if (subType.IsFreshVariable())
        //                dynamicUnionType.AddType(subType);
        //            else {
        //                aux = (int) subType.AcceptOperation(new PromotionLevelOperation(superType));
        //                if (aux != -1)
        //                    return superType;
        //            }
        //        }
        //        if (!this.IsDynamic) {
        //            // * Static
        //            aux = (int)subType.AcceptOperation(new PromotionLevelOperation(superType));
        //            if (aux == -1) {
        //                ErrorManager.Instance.NotifyError(new TypePromotionError(this.FullName, superType.FullName, op.ToString(), loc));
        //                return null;
        //            }
        //        }
        //    }
        //    if (dynamicUnionType.Count != 0) {
        //        // * If the union type is dynamic and no type in the type set promotes, then we generate a constraint with one promotion grouping the fresh types in the type set
        //        PromotionConstraint constraint = new PromotionConstraint(dynamicUnionType, superType, op, loc);
        //        methodAnalyzed.AddConstraint(constraint);
        //        return superType;
        //    }
        //    if (this.IsDynamic && aux == -1) {
        //        // * No promotion at all
        //        ErrorManager.Instance.NotifyError(new TypePromotionError(this.FullName, superType.FullName, op.ToString(), loc));
        //        return null;
        //    }
        //    return superType;
        //}
        #endregion

        #region SuperType()
        public int SuperType(TypeExpression subType) {
            // * Takes the lower promotion level (except -1)
            int lowerLevelOfPromotion = Int32.MaxValue;
            foreach (TypeExpression superType in this.typeSet) {
                int aux = (int) subType.AcceptOperation(new PromotionLevelOperation(superType), null);
                if (aux != -1 && aux < lowerLevelOfPromotion)
                    lowerLevelOfPromotion = aux;
            }
            return lowerLevelOfPromotion == Int32.MaxValue ? -1 : lowerLevelOfPromotion;
        }

        #endregion

        // WriteType Unification

        #region Unify
        public override bool Unify(TypeExpression te, SortOfUnification unification, IList<Pair<TypeExpression, TypeExpression>> previouslyUnified) {
            // * Infinite recursion detection
            Pair<TypeExpression, TypeExpression> pair = new Pair<TypeExpression, TypeExpression>(this, te);
            if (previouslyUnified.Contains(pair))
                return true;
            previouslyUnified.Add(pair);

            // * First checks that all the expression are equivalent. Otherwise substitutions could be
            //   partially applied to type variables that should finally not be unified
            bool equivalent = true;
            foreach (TypeExpression type in this.typeSet)
                if (!(equivalent = (bool)type.AcceptOperation(new EquivalentOperation(te), null)))
                    break;
            if (!equivalent)
                return false;
            // * Lets unify, incrementing type variables with union types
            foreach (TypeExpression type in this.typeSet)
                // * Unification of union types is incremental
                te.Unify(type, SortOfUnification.Incremental, previouslyUnified);
            // * Clears the type expression cache
            this.ValidTypeExpression = false;
            te.ValidTypeExpression = false;
            return true;
        }
        #endregion

        #region HasTypeVariables()
        public override bool HasTypeVariables() {
            if (this.validHasTypeVariables)
                return this.hasTypeVariablesCache;
            bool toReturn = false;
            foreach (TypeExpression type in this.typeSet)
                if (type.HasTypeVariables()) {
                    toReturn = true;
                    break;
                }
            this.validHasTypeVariables = true;
            return this.hasTypeVariablesCache = toReturn;
        }
        #endregion

        #region IsFreshVariable()

        public override bool IsFreshVariable() {
            foreach (TypeExpression type in this.typeSet)
                if (!type.IsFreshVariable())
                    return false;
            return true;
        }
        #endregion

        #region CloneTypeVariables()
        public override TypeExpression CloneTypeVariables(IDictionary<TypeVariable, TypeVariable> typeVariableMappings, IList<EquivalenceClass> equivalenceClasses, IList<ClassType> clonedClasses) {
            if (!this.HasTypeVariables())
                return this;
            UnionType newType = (UnionType)this.MemberwiseClone();
            IList<TypeExpression> oldTypeSet = this.typeSet;
            newType.typeSet = new List<TypeExpression>();
            foreach (TypeExpression oldType in oldTypeSet)
                newType.typeSet.Add(oldType.CloneTypeVariables(typeVariableMappings, equivalenceClasses, clonedClasses));
            newType.ValidTypeExpression = false;
            return newType;
        }
        #endregion

        // Helper Methods

        #region collect()

        public static TypeExpression collect(TypeExpression collection, TypeExpression newType)
        {
            if (newType == null)
                return collection;
            if (collection == null)
                return newType;
            UnionType union = collection as UnionType;
            if (collection != null)
                union = new UnionType(collection);
            if (newType is UnionType)
            {
                // both types are unions
                union.AddType(newType);
                return union;
            }
            if (union.AddType(newType))
                return union;
            // * If two elements are the same, retuns the first
            return collection;
        }


        #endregion

        #region UpdateEquivalenceClass()
        public override void UpdateEquivalenceClass(IDictionary<TypeVariable, TypeVariable> typeVariableMappings, IList<TypeExpression> previouslyUpdated) {
            // * Checks infinite loops
            if (previouslyUpdated.Contains(this))
                return;
            previouslyUpdated.Add(this);

            // * Updates the equivalence class
            if (!this.HasTypeVariables())
                return;
            foreach (TypeExpression type in this.typeSet)
                if (type.HasTypeVariables()) {
                    type.UpdateEquivalenceClass(typeVariableMappings, previouslyUpdated);
                    type.ValidTypeExpression = false;
                }
            this.ValidTypeExpression = false;
        }
        #endregion

        #region ReplaceTypeVariables()
        public override void ReplaceTypeVariables(IDictionary<TypeVariable, TypeVariable> typeVariableMappings) {
            if (!this.HasTypeVariables())
                return;
            for (int i = 0; i < this.typeSet.Count; i++) {
                TypeVariable typeVariable = this.typeSet[i] as TypeVariable;
                if (typeVariable == null) {
                    if (this.typeSet[i].HasTypeVariables())
                        this.typeSet[i].ReplaceTypeVariables(typeVariableMappings);
                }
                else if (typeVariableMappings.ContainsKey(typeVariable))
                    this.typeSet[i] = typeVariableMappings[typeVariable];
                this.ValidTypeExpression = false;
            }
        }
        #endregion

        #region Freeze()
        public override TypeExpression Freeze() {
            return this.Freeze(new List<TypeExpression>());
        }

        public TypeExpression Freeze(IList<TypeExpression> evaluated)
        {
            if (!this.HasTypeVariables())
                return this;
            UnionType newUnionType = new UnionType();
            foreach (TypeExpression type in this.TypeSet)
            {
                if(evaluated.Contains(type))
                    continue;
                else
                    evaluated.Add(type);
                if (type is TypeVariable)
                    newUnionType.AddType(((TypeVariable)type).Freeze(evaluated));
                else
                {
                    if (type is UnionType)
                        newUnionType.AddType(((UnionType) type).Freeze(evaluated));
                    else
                        newUnionType.AddType(type.Freeze());
                }
            }
            return newUnionType;
        }
        #endregion

        // SSA

        #region Clone()
        internal override TypeExpression Clone(IDictionary<int, TypeVariable> clonedTypeVariables, IList<EquivalenceClass> equivalenceClasses, MethodType methodAnalyzed) {
            if (!this.HasTypeVariables())
                return this;
            UnionType newUnionType = (UnionType)this.MemberwiseClone();
            newUnionType.typeSet = new List<TypeExpression>();
            // * Clones all the types in the union
            foreach (TypeExpression type in this.typeSet)
                newUnionType.typeSet.Add(type.Clone(clonedTypeVariables, equivalenceClasses, methodAnalyzed));
            return newUnionType;
        }
        #endregion

        // Loop Detection

        #region Remove()
        public override bool Remove(TypeVariable toRemove) {
            int i;
            for (i = 0; i < this.typeSet.Count; i++) {
                TypeVariable typeVariable = this.typeSet[i] as TypeVariable;
                if (typeVariable != null && typeVariable.Variable == toRemove.Variable) {
                    this.typeSet.RemoveAt(i);
                    this.ValidTypeExpression = false;
                    break;
                }
                if (this.typeSet[i].Remove(toRemove)) {
                    this.typeSet[i].ValidTypeExpression = false;
                    break;
                }
            }
            return i < this.typeSet.Count;
        }
        #endregion

        // Code Generation

        #region ILType()

        public override string ILType() {
            return "object";
        }

        #endregion

        #region IsValueType()

        public override bool IsValueType() {
            return IsValueType(new List<TypeExpression>());
        }

        public bool IsValueType(IList<TypeExpression> evaluated)
        {
            foreach (TypeExpression type in this.TypeSet)
            {
                if (evaluated.Contains(type))
                    continue;
                else
                    evaluated.Add(type);
                // * If Dynamic, a value type is enough);
                if (this.IsDynamic)
                {
                    if (type is UnionType)
                        if(((UnionType)type).IsValueType(evaluated))
                            return true;
                    if (type is TypeVariable)
                        if(((TypeVariable)type).IsValueType(evaluated))
                            return true;
                    if (type.IsValueType())
                        return true;
                }
                // * If Static, all types must be value types
                else 
                {
                    if (type is UnionType)
                    {
                        if (!((UnionType) type).IsValueType(evaluated))
                            return false;
                    }
                    else if (type is TypeVariable)
                    {
                        if (!((TypeVariable) type).IsValueType(evaluated))
                            return false;
                    }
                    else if (!type.IsValueType())
                            return false;                    
                }
            }
            if (this.IsDynamic)
                // * None is value type
                return false;
            // * Static: All are value types
            return true;
        }

        #endregion

        #region HasFreshVariable()

        public override bool HasFreshVariable() {
            foreach (TypeExpression type in this.typeSet)
                if (type.IsFreshVariable())
                    return true;
            return false;
        }
        #endregion

        #region HasIntersectionVariable()

        public override bool HasIntersectionVariable() {
            foreach (TypeExpression type in this.typeSet)
                if (TypeExpression.Is<IntersectionType>(type))
                    return true;
            return false;
        }
        #endregion

        #region ContainsValueType()

        public bool ContainsValueType(TypeExpression type) {
            for (int i = 0; i < this.typeSet.Count; i++) {
                if (this.typeSet[i].IsValueType()) {
                    if (this.typeSet[i] == type)
                        return true;
                }
            }
            return false;
        }

        #endregion

        #region ContainsDifferentReturns()

        public bool ContainsDifferentReturns() {
            TypeExpression current = null;
            TypeExpression aux = null;

            for (int i = 0; i < this.typeSet.Count; i++) {
                if (this.typeSet[i] is TypeVariable)
                    return true;
                MethodType mt = null;
                if ((mt = TypeExpression.As<MethodType>(this.typeSet[i])) != null) {
                    current = mt.Return;
                    if (aux != null && aux != current) // This comparation searches differents value types.
                        return true;
                    aux = current;
                }
            }
            return false;
        }

        #endregion

    }
}