TypeExpression.cs

Go to the documentation of this file.

// -------------------------------------------------------------------------- //
// Project rROTOR                                                             //
// -------------------------------------------------------------------------- //
// File: TypeExpression.cs                                                    //
// Authors: Cristina Gonzalez Muñoz  -  cristi.gm@gmail.com                   //
//          Francisco Ortin - francisco.ortin@gmail.com                       //
// Description:                                                               //
//    Abstract class that represents all different types.                     //
//    Implements Composite pattern [Component].                               //
// -------------------------------------------------------------------------- //
// Create date: 15-10-2006                                                    //
// Modification date: 05-06-2007                                              //

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

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

namespace TypeSystem {
    public abstract class TypeExpression {
        
        #region Fields

        internal protected string typeExpression;

        internal protected string fullName;

        protected bool validTypeExpression = false;

        protected bool hasTypeVariablesCache;

        protected bool validHasTypeVariables = false;

        public const int MAX_DEPTH_LEVEL_TYPE_EXPRESSION = 1;

        protected bool isDynamic;
        #endregion

        #region Properties

        public virtual string FullName {
            get { return this.fullName; }
            set { this.fullName = value; }
        }

        internal virtual bool ValidTypeExpression {
            get { return validTypeExpression; }
            set {
                validTypeExpression = value;
                if (!value) {
                    // * Updates the full name
                    this.BuildFullName();
                    this.typeExpression = this.fullName;
                }
            }
        }

        public virtual bool IsDynamic {
            get { return this.isDynamic; }
            set { this.isDynamic = value; }
        }
        #endregion

        // * Constructors

        #region Construtors
        public TypeExpression() {
            this.isDynamic = false;
        }
        public TypeExpression(bool isDynamic) {
            this.isDynamic = isDynamic;
        }
        #endregion

        // * Debug

        #region ToString()

        public override string ToString() {
            if (!this.ValidTypeExpression) {
                this.typeExpression = this.BuildTypeExpressionString(MAX_DEPTH_LEVEL_TYPE_EXPRESSION);
                this.ValidTypeExpression = true;
            }
            return this.typeExpression;
        }

        #endregion

        #region BuildTypeExpressionString()
        public virtual string BuildTypeExpressionString(int depthLevel) {
            return this.typeExpression;
        }
        #endregion

        #region BuildFullName()
        public virtual void BuildFullName() { }
        #endregion

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

        #region Dot() ANULADA
        //public virtual TypeExpression Dot(string member, MethodType methodAnalyzed, IList<TypeExpression> previousDot, Location loc) {
        //    ErrorManager.Instance.NotifyError(new OperationNotAllowedError(".", this.fullName, loc));
        //    return null;
        //}
        //public virtual TypeExpression Dot(string memberName, IList<TypeExpression> previousDot) {
        //    return null;
        //}
        #endregion

        #region Parenthesis() ANULADA
        //public virtual TypeExpression Parenthesis(TypeExpression actualImplicitObject, TypeExpression[] arguments, MethodType methodAnalyzed, SortOfUnification activeSortOfUnification, Location loc) {
        //    ErrorManager.Instance.NotifyError(new OperationNotAllowedError("()", this.fullName, loc));
        //    return null;
        //}
        #endregion

        #region Bracket() ANULADA
        //public virtual TypeExpression Bracket(TypeExpression index, MethodType methodAnalized, bool showErrorMessage, Location loc) {
        //    if (showErrorMessage)
        //        ErrorManager.Instance.NotifyError(new OperationNotAllowedError("[]", this.fullName, loc));
        //    return null;
        //}

        #endregion

        #region Assignment() ANULADA
        //public virtual TypeExpression Assignment(TypeExpression operand, AssignmentOperator op, MethodType methodAnalyzed, SortOfUnification unification,
        //                TypeExpression actualImplicitObject, Location location) {
        //    ErrorManager.Instance.NotifyError(new AssignmentError(operand.FullName, this.fullName, location));
        //    return null;
        //}
        #endregion

        #region Arithmetic() ANULADA
        /*
         * /// <summary>
        public virtual TypeExpression Arithmetic(TypeExpression operand, Enum op, MethodType methodAnalyzed, bool showErrorMessage, Location loc) {
            if (showErrorMessage)
                ErrorManager.Instance.NotifyError(new OperationNotAllowedError(op.ToString(), this.fullName, operand.fullName, loc));
            return null;
        }
        

        public virtual TypeExpression Arithmetic(UnaryOperator op, MethodType methodAnalyzed, bool showErrorMessage, Location loc) {
            if (showErrorMessage)
                ErrorManager.Instance.NotifyError(new OperationNotAllowedError(op.ToString(), this.fullName, loc));
            return null;
        }
         */
        #endregion

        #region Relational() ANULADA
        /*       /// <summary>
        public virtual TypeExpression Relational(TypeExpression operand, RelationalOperator op, MethodType methodAnalyzed, bool showErrorMessage, Location loc) {
            if (showErrorMessage)
                ErrorManager.Instance.NotifyError(new OperationNotAllowedError(op.ToString(), this.fullName, operand.fullName, loc));
            return null;
        }
        
        */
        #endregion

        #region Equivalent() ANULADA
        //public virtual bool Equivalent(TypeExpression type) {
        //    if (this == type)
        //        return true;
        //    TypeVariable typeVariable = type as TypeVariable;
        //    if (typeVariable != null)
        //        return typeVariable.Equivalent(this);
        //    return this.fullName.Equals(type.fullName);
        //}
        #endregion

        #region AsClassType()
        public virtual ClassType AsClassType() {
            return null;
        }

        #endregion

        // WriteType Promotion

        #region PromotionLevel() ANULADA
        //public virtual int PromotionLevel(TypeExpression type) {
        //    return -1;
        //}
        #endregion

        #region Promotion() ANULADA
        //public virtual TypeExpression Promotion(TypeExpression type, MethodType methodAnalyzed, Location location) {
        //    if ((int) this.AcceptOperation(new PromotionLevelOperation(type)) == -1) {
        //        ErrorManager.Instance.NotifyError(new TypePromotionError(this.FullName, type.FullName, location));
        //        return null;
        //    }
        //    return type;
        //}
        //public virtual TypeExpression Promotion(TypeExpression type, Enum op, MethodType methodAnalyzed, Location location) {
        //    if ((int)this.AcceptOperation( new PromotionLevelOperation(type)) == -1) {
        //        ErrorManager.Instance.NotifyError(new TypePromotionError(this.FullName, type.FullName, op.ToString(), location));
        //        return null;
        //    }
        //    return type;
        //}
        #endregion

        #region Cast() ANULADA
        //public virtual TypeExpression Cast(TypeExpression castType, MethodType methodAnalyzed, Location loc) {
        //    if (castType == null)
        //        return null;
        //    if (((int)castType.AcceptOperation(new PromotionLevelOperation(this)) != -1) || ((int)this.AcceptOperation(new PromotionLevelOperation(castType)) != -1))
        //        return castType;
        //    ErrorManager.Instance.NotifyError(new TypeCastError(this.FullName, castType.FullName, loc));
        //    return null;
        //}
        #endregion

        #region EqualsForOverload() ANULADA
        //public virtual bool EqualsForOverload(object typeExpression) {
        //    // * By default, we use the equals comparison
        //    return this.Equals(typeExpression);
        //}
        #endregion

        // WriteType Unification

        #region Unify()
        public abstract bool Unify(TypeExpression te, SortOfUnification unification, IList<Pair<TypeExpression, TypeExpression>> previouslyUnified);
        #endregion

        #region HasTypeVariables()
        public virtual bool HasTypeVariables() {
            return false;
        }
        #endregion

        #region IsFreshVariable()
        public virtual bool IsFreshVariable() {
            return false;
        }
        #endregion

        #region HasFreshVariable()
        public virtual bool HasFreshVariable() {
            return IsFreshVariable();
        }
        #endregion

        #region HasIntersectionVariable()
        public virtual bool HasIntersectionVariable() {
            return false;
        }
        #endregion


        #region CloneType()
        public virtual TypeExpression CloneType(IDictionary<TypeVariable, TypeVariable> typeVariableMappings) {
            // * By default, no clone is performed (built-in types)
            return this;
        }
        #endregion

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

        #region UpdateEquivalenceClass()
        public virtual void UpdateEquivalenceClass(IDictionary<TypeVariable, TypeVariable> typeVariableMappings, IList<TypeExpression> previouslyUpdated) {
            // * Does nothing (built-in types are not recursive)
        }
        #endregion

        #region ReplaceTypeVariables()
        public virtual void ReplaceTypeVariables(IDictionary<TypeVariable, TypeVariable> typeVariableMappings) {
            // * Nothing to to (built-in types)
        }
        #endregion

        #region Freeze()
        public virtual TypeExpression Freeze() {
            return this;
        }
        #endregion

        // SSA

        #region Clone()
        internal virtual TypeExpression Clone(IDictionary<int, TypeVariable> clonedTypeVariables, IList<EquivalenceClass> equivalenceClasses, MethodType methodAnalyzed) {
            if (this.HasTypeVariables())
                throw new InvalidOperationException("The type should implement a Clone method.");
            // * Default implementation (types with no type variables)
            return this;
        }
        #endregion

        // Loop Detection

        #region Remove()
        public virtual bool Remove(TypeVariable toRemove) {
            return false;
        }
        #endregion

        // Code Generation

        #region ILType()
        public virtual string ILType() {
            return this.fullName;
        }

        #endregion

        #region IsValueType()
        public abstract bool IsValueType();
        #endregion

        // Helper Methods

        #region As<T>()
        public static T As<T>(TypeExpression type) where T : TypeExpression {
            TypeVariable typeVariable = type as TypeVariable;
            if (typeVariable != null)
                type = typeVariable.Substitution;
            T castType = type as T;
            return castType;
        }
        #endregion
        
        #region Is<T>()
        public static bool Is<T>(TypeExpression type) where T : TypeExpression {
            return TypeExpression.As<T>(type) != null;
        }
        #endregion

        virtual public BCLClassType getBCLType() {
            System.Diagnostics.Debug.Assert(true, "getBCLType called in type expression inconsistence in the program");
            return null;
        }

    }
}