ClassTypeProxy.cs

Go to the documentation of this file.

// -------------------------------------------------------------------------- 
// Project rROTOR                                                             
// -------------------------------------------------------------------------- 
// File: ClassTypeProxy.cs                                                        
// Author: Francisco Ortin - francisco.ortin@gmail.com                       
// Description:                                                               
//    Represents proxy of a class type. It is needed when a class has a 
//        field that is recursively of the same class. It implements a
//        lazy clone type variables scheme.
//    Implements the unfold operatations of theoretical type systes.
//    Inheritance: TypeExpression.                                                  
//    Implements Composite pattern [Composite].                               
//    Implements Proxy pattern [Proxy].                               
// -------------------------------------------------------------------------- 
// Create date: 02-05-2007
// Modification date: 02-05-2007

using System;
using System.Collections.Generic;
using System.Text;

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

namespace TypeSystem {
    public class ClassTypeProxy : TypeExpression {
        #region Fields

        private ClassType realType = null;

        private ClassType originalClass;

        private IDictionary<TypeVariable, TypeVariable> typeVariableMappings;

        private IList<EquivalenceClass> equivalenceClasses;
        #endregion

        #region Properties
        public ClassType RealType {
            get {
                this.unfold();
                return this.realType;
            }
        }
        //public ClassType OriginalClass {
        //    get {return this.originalClass}
        //}
        #endregion

        #region Constructors
        public ClassTypeProxy(ClassType originalClass, IDictionary<TypeVariable, TypeVariable> typeVariableMappings, IList<EquivalenceClass> equivalenceClasses) {
            this.originalClass = originalClass;
            this.typeVariableMappings = typeVariableMappings;
            this.equivalenceClasses = equivalenceClasses;
            this.fullName = originalClass.FullName;
        }
        #endregion

        #region unfold()
        private void unfold() {
            if (this.realType == null) {
                this.realType = (ClassType)this.originalClass.CloneTypeVariables(this.typeVariableMappings, this.equivalenceClasses, new List<ClassType>());
                // * For each equivalence class we create a new one, 
                //   substituting the old type variables for the new ones
                // * The substitution is not altered
                // * Since equivalence classes and type variables have a bidirectional association,
                //   the new equivalence classes will make type variables update their new equivalence classes
                foreach (EquivalenceClass equivalenceClass in equivalenceClasses)
                    equivalenceClass.UpdateEquivalenceClass(typeVariableMappings);
                // * The new class type is returned
                this.realType.ValidTypeExpression = false;
            }
        }

        #endregion

        #region BuildTypeExpressionString()

        public override string BuildTypeExpressionString(int depthLevel) {
            if (this.realType.ValidTypeExpression)
                return this.realType.typeExpression;
            return this.realType.FullName;
        }

        #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 loc) {
        //    return this.RealType.Assignment(operand, op, methodAnalyzed, unification, actualImplicitObject, loc);
        //}
        #endregion

        #region Dot() ANULADA
        //public override TypeExpression Dot(string memberName, MethodType methodAnalyzed, IList<TypeExpression> previousDot, Location loc) {
        //    return this.RealType.Dot(memberName, methodAnalyzed, previousDot, loc);
        //}
        //public override TypeExpression Dot(string memberName, IList<TypeExpression> previousDot) {
        //    return this.RealType.Dot(memberName, previousDot);
        //}
        #endregion

        #region Parenthesis() ANULADA
        //public override TypeExpression Parenthesis(TypeExpression actualImplicitObject, TypeExpression[] arguments, MethodType methodAnalyzed,
        //                    SortOfUnification activeSortOfUnification, Location loc) {
        //    return this.RealType.Parenthesis(actualImplicitObject, arguments, methodAnalyzed, activeSortOfUnification, loc);
        //}
        #endregion

        #region AsClassType() ANULADA
        public override ClassType AsClassType() {
            return this.originalClass;
        }
        #endregion

        #region Equivalent() ANULADA
        #endregion

        // WriteType Promotion

        #region PromotionLevel() ANULADA
        //public override int PromotionLevel(TypeExpression type) {
        //    return this.RealType.PromotionLevel(type);
        //}
        #endregion

        #region Promotion() ANULADA
        //public override TypeExpression Promotion(TypeExpression type, MethodType methodAnalyzed, Location loc) {
        //    return this.RealType.Promotion(type, methodAnalyzed, loc);
        //}
        //public override TypeExpression Promotion(TypeExpression type, Enum op, MethodType methodAnalyzed, Location loc) {
        //    return this.RealType.Promotion(type, op, methodAnalyzed, loc);
        //}
         #endregion

        #region EqualsForOverload() ANULADA
        //public override bool EqualsForOverload(object typeExpression) {
        //    return this.RealType.EqualsForOverload(typeExpression);
        //}
        #endregion

        // WriteType Unification

        #region Unify
        public override bool Unify(TypeExpression te, SortOfUnification unification, IList<Pair<TypeExpression, TypeExpression>> previouslyUnified) {
            return this.RealType.Unify(te, unification, previouslyUnified);
        }
        #endregion


        #region HasTypeVariables()
        public override bool HasTypeVariables() {
            return this.RealType.HasTypeVariables();
        }

        public bool HasTypeVariables(IList<String> evaluated)
        {
            return this.RealType.HasTypeVariables(evaluated);            
        }
        #endregion

        #region CloneType()
        public override TypeExpression CloneType(IDictionary<TypeVariable, TypeVariable> typeVariableMappings) {
            return this.RealType.CloneType(typeVariableMappings);
        }
        #endregion


        #region CloneTypeVariables()
        public override TypeExpression CloneTypeVariables(IDictionary<TypeVariable, TypeVariable> typeVariableMappings, IList<EquivalenceClass> equivalenceClasses, IList<ClassType> clonedClasses) {
            return this.RealType.CloneTypeVariables(typeVariableMappings, equivalenceClasses, clonedClasses);
        }
        #endregion

        // SSA

        #region Clone()
        internal override TypeExpression Clone(IDictionary<int, TypeVariable> clonedTypeVariables, IList<EquivalenceClass> equivalenceClasses, MethodType methodAnalyzed) {
            if (!this.HasTypeVariables())
                return this;
            ClassTypeProxy newClassProxy = (ClassTypeProxy)this.MemberwiseClone();
            if (newClassProxy.realType != null)
                newClassProxy.realType = (ClassType)newClassProxy.realType.Clone(clonedTypeVariables, equivalenceClasses, methodAnalyzed);
            return newClassProxy;
        }
        #endregion

        // Loop detection

        #region Equals&GetHashCode()
        public override bool Equals(object obj) {
            return this.RealType.Equals(obj);
        }
        public override int GetHashCode() {
            return this.FullName.GetHashCode();
        }
        #endregion

        #region IsValueType()

        public override bool IsValueType()
        {
           return this.realType.IsValueType();
        }

        #endregion

    }
}