IntersectionType.cs

Go to the documentation of this file.

// -------------------------------------------------------------------------- //
// Project rROTOR                                                             //
// -------------------------------------------------------------------------- //
// File: IntersectionType.cs                                                       //
// Authors: Cristina Gonzalez Muñoz  -  cristi.gm@gmail.com                   //
//          Francisco Ortin - francisco.ortin@gmail.com                       //
// Description:                                                               //
//    Represents a disjunction set type.                                      //
//    Inheritance: TypeExpression.                                            //
//    Implements Composite pattern [Composite].                               //
// -------------------------------------------------------------------------- //
// Create date: 27-02-2007                                                    //
// Modification date: 21-03-2007                                              //

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;

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

namespace TypeSystem {
    //VISTO
    public class IntersectionType : TypeExpression {
        #region Fields

        protected 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 IntersectionType() { }
        public IntersectionType(TypeExpression te) {
            this.AddType(te);
            this.BuildFullName();
        }
        #endregion

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

        #region AddType
        public bool AddType(TypeExpression type) {
            bool added = true;
            IntersectionType intersection = TypeExpression.As<IntersectionType>(type);
            if (intersection != null) {
                foreach (TypeExpression t in intersection.typeSet)
                    added = added && this.AddType(t);
                this.ValidTypeExpression = false;
                return added;
            }
            Predicate<TypeExpression> predicate = delegate(TypeExpression te2) {
                return (bool)te2.AcceptOperation(new EquivalentOperation(type), null);
            };
            if (this.typeSet.Find(predicate)== 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 overloadResolution()
        public TypeExpression overloadResolution(TypeExpression[] arguments, Location location) {
            int aux;
            int min = -1, index = -1, minNumFreeVariables = Int32.MaxValue;

            // * We create a dictionary of <index,promotionValue> to remember the promotion values (they could have
            //   repeated values because of type variables)
            Dictionary<int, int> promotionValues = new Dictionary<int, int>();

            if (this.typeSet.Count == 0) {
                System.Diagnostics.Debug.Assert(false, "There should be no empty intersection types.");
                return null;
            }

            for (int i = 0; i < this.typeSet.Count; i++) {
                MethodType mt = TypeExpression.As<MethodType>(this.typeSet[i]);
                if (mt == null)
                    ErrorManager.Instance.NotifyError(new OperationNotAllowedError("()", mt.FullName, location));
                aux = mt.Promotion(arguments, location);
                if (aux != -1)
                    if ((min >= aux) || (min == -1)) {
                        min = aux;
                        index = i;
                        promotionValues[index] = min;
                    }
            }
            // * No method is suitable
            if (index == -1) {
                ErrorManager.Instance.NotifyError(new UnknownMemberError(location));
                return null;
            }
            index = -1;
            // * Gets the min number of free variables
            foreach (KeyValuePair<int, int> pair in promotionValues)
                if (pair.Value == min) {
                    aux = ((MethodType)this.typeSet[pair.Key]).GetNumberFreeVariables();
                    if (aux < minNumFreeVariables)
                        minNumFreeVariables = aux;
                }
            // * Assigns a union of all the best methods
            TypeExpression bestMethods=null;
            foreach (KeyValuePair<int, int> pair in promotionValues)
                if (pair.Value == min && ((MethodType)this.typeSet[pair.Key]).GetNumberFreeVariables() == minNumFreeVariables)
                    bestMethods = UnionType.collect(bestMethods, this.typeSet[pair.Key]);
            // * We've got'em
            return bestMethods;
        }
        #endregion

        #region Parenthesis() ANULADA

        //public override TypeExpression Parenthesis(TypeExpression actualImplicitObject, TypeExpression[] arguments, MethodType methodAnalyzed,
        //                    SortOfUnification activeSortOfUnification, Location loc) {
        //    TypeExpression method = overloadResolution(arguments, loc);
        //    if (method == null)
        //        return null;
        //    return method.Parenthesis(actualImplicitObject, arguments, methodAnalyzed, activeSortOfUnification, loc);
        //}

        #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);

            // * Clears the type expression cache
            this.ValidTypeExpression = false;
            te.ValidTypeExpression = false;
            // TODO
            return false;
        }
        #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 CloneTypeVariables()
        public override TypeExpression CloneTypeVariables(IDictionary<TypeVariable, TypeVariable> typeVariableMappings, IList<EquivalenceClass> equivalenceClasses, IList<ClassType> clonedClasses) {
            if (!this.HasTypeVariables())
                return this;
            IntersectionType newType = (IntersectionType)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

        // SSA

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

        #region IsValueType()

        public override bool IsValueType()
        {
           throw new Exception("The method or operation is not implemented.");
        }

        #endregion


    }
}