ArrayType.cs

Go to the documentation of this file.

// -------------------------------------------------------------------------- //
// Project rROTOR                                                             //
// -------------------------------------------------------------------------- //
// File: ArrayType.cs                                                         //
// Authors: Cristina Gonzalez Muñoz  -  cristi.gm@gmail.com                   //
//          Francisco Ortin - francisco.ortin@gmail.com                       //
// Description:                                                               //
//    Represents an array type.                                               //
//    Inheritance: TypeExpression.                                            //
//    Implements Composite pattern [Composite].                               //
// -------------------------------------------------------------------------- //
// Create date: 27-01-2007                                                    //
// Modification date: 05-06-2007                                              //

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

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

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

        private TypeExpression arrayType;

        private BCLClassType BCLType;

        #endregion

        #region Properties

        public TypeExpression ArrayTypeExpression {
            get { return this.arrayType; }
        }
      

        public override bool IsDynamic {
            set {
                // * If an array is dynamic, so it is its element
                this.isDynamic = value;
                if (this.arrayType != null)
                    this.arrayType.IsDynamic = value;
            }
        }
      
        #endregion

        #region Constructor

        public ArrayType(TypeExpression type) {
            this.arrayType = type;
            this.fullName = type.FullName + "[]";
            string introspectiveName = type.GetType().FullName + "[]";
            this.BCLType = new BCLClassType(this.fullName, Type.GetType(introspectiveName));

        }

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

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

            this.typeExpression = this.typeExpression = String.Format("Array({0})", this.arrayType.BuildTypeExpressionString(depthLevel - 1));
            this.ValidTypeExpression = true;
            return typeExpression;
        }
        #endregion

        #region BuildFullName()
        public override void BuildFullName() {
            this.fullName = this.arrayType.fullName + "[]";
        }
        #endregion

        // WriteType inference

        #region Assignment() ANULAda
        //public override TypeExpression Assignment(TypeExpression operand, AssignmentOperator op, MethodType methodAnalyzed, SortOfUnification unification,
        //            TypeExpression actualImplicitObject, Location location) {
        //    if ((op == AssignmentOperator.Assign) && (operand.Equivalent(this))) {
        //        if (!this.HasTypeVariables())
        //            return this;
        //        // * Unification
        //        if (this.Unify(operand, unification, new List<Pair<TypeExpression, TypeExpression>>()))
        //            return this;
        //        else {
        //            ErrorManager.Instance.NotifyError(new AssignmentError(operand.FullName, this.FullName, location));
        //            return null;
        //        }
        //    }
        //    ErrorManager.Instance.NotifyError(new AssignmentError(operand.FullName, this.FullName, location));
        //    return null;
        //}

        #endregion

        #region Bracket() ANULADA

        //public override TypeExpression Bracket(TypeExpression index, MethodType methodAnalyzed, bool showErrorMessage, Location loc) {
        //    if (index.Promotion(IntType.Instance, ArrayOperator.Indexer, methodAnalyzed, loc) != null)
        //        return this.arrayType;
        //    return null;
        //}

        #endregion

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

        #region Equivalent() ANULADA
        //public override bool Equivalent(TypeExpression type) {
        //    // * Is it an array?
        //    ArrayType arrayType = TypeExpression.As<ArrayType>(type);
        //    if (arrayType != null)
        //        return this.arrayType.Equivalent(arrayType.arrayType);
        //    // * It can be a System.Array
        //    BCLClassType bclClassType = TypeExpression.As<BCLClassType>(type);
        //    if (bclClassType.TypeInfo.IsArray) {
        //        TypeExpression elementType = TypeTable.Instance.GetType(bclClassType.TypeInfo.GetElementType().FullName, new Location("", 0, 0));
        //        return elementType.Equivalent(this);
        //    }
        //    return false;
        //}
        #endregion

        

        #region Relational() ANULADA
        //public override TypeExpression Relational(TypeExpression operand, RelationalOperator op, MethodType methodAnalyzed, bool showErrorMessage, Location loc) {
        //    // * Operators >= > <= < are note allowed
        //    if ((op == RelationalOperator.GreaterThan || op == RelationalOperator.GreaterThanOrEqual || op == RelationalOperator.LessThan || op == RelationalOperator.LessThanOrEqual)
        //         && showErrorMessage) {
        //        ErrorManager.Instance.NotifyError(new OperationNotAllowedError(op.ToString(), this.fullName, operand.fullName, loc));
        //        return null;
        //    }
        //    if (!(operand is NullType))
        //        ErrorManager.Instance.NotifyError(new OperationNotAllowedError(op.ToString(), this.fullName, operand.fullName, loc));
        //    return null;
        //}
        
        #endregion

        // WriteType promotion

        #region PromotionLevel() ANULADA
        //public override int PromotionLevel(TypeExpression type) {
        //    // * Array and bounded type variable
        //    ArrayType array = TypeExpression.As<ArrayType>(type);
        //    if (array != null)
        //       return this.arrayType.Equals(array.arrayType) ? 0 : -1;
        //    // * A free variable is a complete promotion
        //    TypeVariable typeVariable = type as TypeVariable;
        //    if (typeVariable != null && typeVariable.Substitution == null)
        //        return 0;
        //    // * Union type and bounded type variable
        //    UnionType unionType = TypeExpression.As<UnionType>(type);
        //    if (unionType != null)
        //        return unionType.SuperType(this);
        //    // * Field type and bounded type variable
        //    FieldType fieldType = TypeExpression.As<FieldType>(type);
        //    if (fieldType != null)
        //        return this.PromotionLevel(fieldType.FieldTypeExpression);
        //    // * Use the BCL object oriented approach
        //    return this.BCLType.PromotionLevel(type);
        //}
        #endregion

        #region Equals&GetHashCode()
        public override bool Equals(object obj) {
            ArrayType parameter = obj as ArrayType;
            if (parameter == null) 
                return false;
            if (parameter == this)
                return true;
            return this.arrayType.Equals(parameter.arrayType);
        }
        public override int GetHashCode() {
            return this.FullName.GetHashCode();
        }
        #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);

            bool success = false;
            ArrayType at = te as ArrayType;
            if (at != null)
                success = this.arrayType.Unify(at.arrayType, unification, previouslyUnified);
            else if (te is TypeVariable) {
                TypeVariable typeVariable = (TypeVariable)te;
                if (unification != SortOfUnification.Incremental)
                    // * Incremental is commutative
                    success = typeVariable.Unify(this, unification, previouslyUnified);
                else { // * Array(var) should unify to Var=Array(int)
                    if (typeVariable.Substitution != null)
                        success = this.Unify(typeVariable.Substitution, unification, previouslyUnified);
                    else success = false;
                }
            }
            else if (te is UnionType)
                success = te.Unify(this, unification, previouslyUnified);
            // * Clears the type expression cache
            this.ValidTypeExpression = false;
            te.ValidTypeExpression = false;
            return success;
        }
        #endregion

        #region HasTypeVariables()
        public override bool HasTypeVariables() {
            if (this.validHasTypeVariables)
                return this.hasTypeVariablesCache;
            bool toReturn = this.arrayType.HasTypeVariables();
            this.validHasTypeVariables = true;
            return this.hasTypeVariablesCache = toReturn;
        }
        #endregion

        #region CloneType()
        public override TypeExpression CloneType(IDictionary<TypeVariable, TypeVariable> typeVariableMappings) {
            if (!this.HasTypeVariables())
                return this;
            // * We clone the type of the elements
            IList<EquivalenceClass> equivalenceClasses = new List<EquivalenceClass>();
            ArrayType newArrayType = (ArrayType)this.CloneTypeVariables(typeVariableMappings, 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);
            newArrayType.ValidTypeExpression = false;
            // * The new class type is returned
            return newArrayType;
        }
        #endregion

        #region CloneTypeVariables()
        public override TypeExpression CloneTypeVariables(IDictionary<TypeVariable, TypeVariable> typeVariableMappings, IList<EquivalenceClass> equivalenceClasses, IList<ClassType> clonedClasses) {
            if (!this.HasTypeVariables())
                return this;
            ArrayType newType = (ArrayType)this.MemberwiseClone();
            newType.arrayType = newType.arrayType.CloneTypeVariables(typeVariableMappings, equivalenceClasses, clonedClasses);
            newType.ValidTypeExpression = false;
            return newType;
        }
        #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;
            this.arrayType.UpdateEquivalenceClass(typeVariableMappings, previouslyUpdated);
            this.ValidTypeExpression = false;
        }
        #endregion

        #region ReplaceTypeVariables()
        public override void ReplaceTypeVariables(IDictionary<TypeVariable, TypeVariable> typeVariableMappings) {
            TypeVariable arrayTypeVariable = this.arrayType as TypeVariable;
            if (arrayTypeVariable == null) {
                if (this.arrayType.HasTypeVariables())
                    this.arrayType.ReplaceTypeVariables(typeVariableMappings);
                return;
            }
            if (typeVariableMappings.ContainsKey(arrayTypeVariable))
                this.arrayType = typeVariableMappings[arrayTypeVariable];
            this.ValidTypeExpression = false;
        }
        #endregion

        // SSA

        #region Clone()
        internal override TypeExpression Clone(IDictionary<int, TypeVariable> clonedTypeVariables, IList<EquivalenceClass> equivalenceClasses, MethodType methodAnalyzed) {
            if (!this.HasTypeVariables())
                return this;
            ArrayType newType = (ArrayType)this.MemberwiseClone();
            newType.arrayType = newType.arrayType.Clone(clonedTypeVariables, equivalenceClasses, methodAnalyzed);
            newType.ValidTypeExpression = false;
            return newType;
        }
        #endregion

        // Code Generation

        #region ILType()

        public override string ILType() {
            if (this.ArrayTypeExpression is TypeVariable && ((TypeVariable)this.ArrayTypeExpression).Substitution != null && ((TypeVariable)this.ArrayTypeExpression).Substitution.IsValueType())            
                return "object[]";            
            else            
                return this.arrayType.ILType() + "[]";                         
        }

        #endregion

        #region IsValueType()

        public override bool IsValueType()
        {
           return false;
        }

        #endregion

    }
}