FieldType.cs

Go to the documentation of this file.

// -------------------------------------------------------------------------- //
// Project rROTOR                                                             //
// -------------------------------------------------------------------------- //
// File: FieldType.cs                                                         //
// Authors: Cristina Gonzalez Muñoz  -  cristi.gm@gmail.com                   //
//          Francisco Ortin - francisco.ortin@gmail.com                       //
// Description:                                                               //
//    Represents a field type.                                                //
//    Inheritance: MemberType.                                                //
//    Implements Composite pattern [Composite].                               //
// -------------------------------------------------------------------------- //
// Create date: 27-01-2007                                                    //
// Modification date: 11-06-2007                                              //

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

using AST;
using ErrorManagement;
using TypeSystem.Constraints;
using Tools;
using DynVarManagement;
using TypeSystem.Operations;
//visto
namespace TypeSystem {
    public class FieldType : TypeExpression, IMemberType {
        #region Fields

        private TypeExpression fieldType;

        private AccessModifier memberInfo;


        #endregion

        #region Properties

        public TypeExpression FieldTypeExpression {
            get { return this.fieldType; }
        }

        public AccessModifier MemberInfo {
            get { return this.memberInfo; }
            set {
                if (this.memberInfo == null) {
                    this.memberInfo = value;
                }
                else
                    ErrorManager.Instance.NotifyError(new ClassTypeInfoError(this.memberInfo.MemberIdentifier, this.memberInfo.Class.FullName, value.Class.FullName));
            }
        }

        internal override bool ValidTypeExpression {
            set {
                validTypeExpression = value;
                if (!value) {
                    // * Updates the full name
                    this.BuildFullName();
                }
            }
        }

        #endregion

        #region Constructor

        public FieldType(TypeExpression type) {
            if (type != null) {
                this.fieldType = type;
                this.fullName = type.fullName;
            }
        }

        #endregion

        #region BuildTypeExpressionString

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

            //this.fullName = this.MemberInfo.Class.FullName + "." + this.MemberInfo.MemberIdentifier;
            if (this.fieldType == null)
                return "null";
            this.fullName = this.fieldType.FullName;

            StringBuilder tE = new StringBuilder();
            // tE: Field(IdClass, IdField, mods, type)
            tE.AppendFormat("Field({0}, {1},", this.MemberInfo.Class.BuildTypeExpressionString(depthLevel - 1), this.MemberInfo.MemberIdentifier);
            // modifiers
            if (this.MemberInfo.Modifiers.Count != 0) {
                for (int i = 0; i < this.MemberInfo.Modifiers.Count - 1; i++) {
                    tE.AppendFormat(" {0} x", this.MemberInfo.Modifiers[i]);
                }
                tE.AppendFormat(" {0}", this.MemberInfo.Modifiers[this.MemberInfo.Modifiers.Count - 1]);
            }
            tE.Append(", ");

            // type
            tE.Append(this.fieldType.BuildTypeExpressionString(depthLevel - 1));
            tE.Append(")");
            this.ValidTypeExpression = true;
            return this.typeExpression = tE.ToString();
        }
        #endregion

        #region BuildFullName()
        public override void BuildFullName() {
            this.fieldType.BuildFullName();
            this.fullName = this.fieldType.fullName;
        }
        #endregion

        // WriteType inference

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

        #region Dot() ANULADA

        //public override TypeExpression Dot(string field, MethodType methodAnalyzed, IList<TypeExpression> previousDot, Location loc) {
        //    if (this.fieldType != null) {
        //        // * If the field type is a dynamic union type, so it is the union
        //        UnionType unionType = As<UnionType>(this.fieldType);
        //        if (unionType != null)
        //            DynVarOptions.Instance.AssignDynamism(this.fieldType, this.IsDynamic);
        //        return this.fieldType.Dot(field, methodAnalyzed, previousDot, loc);
        //    }
        //    return null;
        //}
        //public override TypeExpression Dot(string memberName, IList<TypeExpression> previousDot) {
        //    if (this.fieldType != null)
        //        return this.fieldType.Dot(memberName, previousDot);
        //    return null;
        //}
        #endregion

        //#region Bracket() anulada

        //public override TypeExpression Bracket(TypeExpression index, MethodType methodAnalyzed, bool showErrorMessage, Location loc) {
        //    if (this.fieldType != null)
        //        return this.fieldType.Bracket(index, methodAnalyzed, showErrorMessage, loc);
        //    return null;
        //}

        //#endregion

        #region Assignment() ANULADA
        //public override TypeExpression Assignment(TypeExpression operand, AssignmentOperator op, MethodType methodAnalyzed, SortOfUnification unification,
        //            TypeExpression actualImplicitObject, Location location) {
        //    // * We check if a constraint must be generated. Is it an assignment of the implicit object's field?
        //    bool found = false;
        //    // * In case it has free variables and the reference used is this, we add a constraint to the method
        //    if (this.HasTypeVariables() && methodAnalyzed != null && ClassType.IsConcreteType(actualImplicitObject) == null) {
        //        // * They should be the same exact (sub)classes. This represent the same instance, not another instance of the same class.
        //        ClassType methodSuperClass = (ClassType)methodAnalyzed.MemberInfo.Class;
        //        while (!(found = (this.MemberInfo.Class == methodSuperClass)) && methodSuperClass != null)
        //            methodSuperClass = methodSuperClass.BaseClass;
        //        if (found) {
        //            // * An assignment constraint is added, postponing the type inference
        //            // * If an actual implicit object is used, we take its field's type
        //            FieldType fieldType = this;
        //            ClassType thisType = TypeExpression.As<ClassType>(actualImplicitObject);
        //            if (thisType == null) {
        //                FieldType field = TypeExpression.As<FieldType>(actualImplicitObject);
        //                if (field != null)
        //                    thisType = TypeExpression.As<ClassType>(field.FieldTypeExpression);
        //            }
        //            if (thisType != null)
        //                fieldType = (FieldType)thisType.Fields[this.MemberInfo.MemberIdentifier].WriteType;
        //            methodAnalyzed.AddConstraint(new FieldTypeAssignmentConstraint(fieldType, operand, unification));
        //            methodAnalyzed.ValidTypeExpression = false;
        //            return this.fieldType;
        //        }
        //    }
        //    if (!found && this.fieldType != null)
        //        return this.fieldType.Assignment(operand, op, null, unification, actualImplicitObject, location);
        //    return null;
        //}

        #endregion

       #region Arithmetic() >NUL>C>
        /*
        public override TypeExpression Arithmetic(TypeExpression operand, Enum op, MethodType methodAnalyzed, bool showErrorMessage, Location loc) {
            if (this.fieldType != null)
                return this.fieldType.Arithmetic(operand, op, methodAnalyzed, showErrorMessage, loc);
            return null;
        }

        public override TypeExpression Arithmetic(UnaryOperator op, MethodType methodAnalyzed, bool showErrorMessage, Location loc) {
            return this.fieldType.Arithmetic(op, methodAnalyzed, showErrorMessage, loc);
        }
        */
       #endregion

        #region Relational()ANULADA
        /*      /// <summary>
        public override TypeExpression Relational(TypeExpression operand, RelationalOperator op, MethodType methodAnalyzed, bool showErrorMessage, Location loc) {
            if (this.fieldType != null)
                return this.fieldType.Relational(operand, op, methodAnalyzed, showErrorMessage, loc);
            return null;
        }

        */
        #endregion

        #region PromotionLevl()-->#        
        //public override int PromotionLevel(TypeExpression type) {
        //    if (this.fieldType != null)
        //        return this.fieldType.PromotionLevel(type);
        //    return -1;
        //}
#endregion
        #region Promotion ANULADA
        //public override TypeExpression Promotion(TypeExpression type, Enum op, MethodType methodAnalyzed, Location loc) {
        //    if (this.fieldType != null)
        //        return this.fieldType.Promotion(type, op, methodAnalyzed, loc);
        //    return null;
        //}
        #endregion

        #region Cast() ANULADA
        //public override TypeExpression Cast(TypeExpression castType, MethodType methodAnalyzed, Location loc) {
        //    if (this.fieldType != null)
        //        return this.fieldType.Cast(castType, methodAnalyzed, loc);
        //    return null;
        //}
        #endregion


        // WriteType Unification

        #region Unify
        public override bool Unify(TypeExpression te, SortOfUnification unification, IList<Pair<TypeExpression, TypeExpression>> previouslyUnified) {
            FieldType ft = te as FieldType;
            if (ft != null) {
                bool success = this.fieldType.Unify(ft.fieldType, unification, previouslyUnified);
                if (success) // * Dynamic type
                    DynVarOptions.Instance.AssignDynamism(this, ft.isDynamic);
                // * Clears the type expression cache
                this.ValidTypeExpression = false;
                te.ValidTypeExpression = false;
                return success;
            }
            if (te is TypeVariable && unification != SortOfUnification.Incremental)
                // * No incremental unification is commutative
                return te.Unify(this, unification, previouslyUnified);
            if (te is ClassType && unification == SortOfUnification.Equivalent)
                return te.Unify(this, unification, previouslyUnified);
            if (te.IsValueType() && unification == SortOfUnification.Equivalent)
                return te.Unify(this, unification, previouslyUnified);
            return false;
        }
        #endregion

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

        }

        public bool HasTypeVariables(IList<String> evaluated)
        {
            if (this.validHasTypeVariables)
                return this.hasTypeVariablesCache;

            bool toReturn;
            if (this.fieldType is UserType)
                toReturn = ((UserType) this.fieldType).HasTypeVariables(evaluated);
            else if(this.fieldType is ClassTypeProxy)
                toReturn = ((ClassTypeProxy)this.fieldType).HasTypeVariables(evaluated);
            else
                toReturn = this.fieldType.HasTypeVariables();
            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;
            AccessModifier accesModifier = (AccessModifier)this.MemberInfo.Clone();
            FieldType fieldType = new FieldType(this.FieldTypeExpression.CloneTypeVariables(typeVariableMappings, equivalenceClasses, clonedClasses));
            accesModifier.Class = this.MemberInfo.Class;
            accesModifier.Type = fieldType;
            fieldType.IsDynamic = this.IsDynamic;
            fieldType.MemberInfo = accesModifier;
            this.ValidTypeExpression = fieldType.ValidTypeExpression = false;
            return fieldType;
        }
        #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.fieldType.UpdateEquivalenceClass(typeVariableMappings, previouslyUpdated);
            this.ValidTypeExpression = false;
        }
        #endregion

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

        #region Equivalent ANULADA
        //public override bool Equivalent(TypeExpression type) {
        //    FieldType fieldType = type as FieldType;
        //    if (fieldType != null)
        //        return this.fieldType.Equivalent(fieldType.fieldType);
        //    return this.fieldType.Equivalent(type);
        //}

        #endregion
        #region Freeze()
        public override TypeExpression Freeze() {
            if (this.FieldTypeExpression is TypeVariable && !this.FieldTypeExpression.IsFreshVariable()) {
                FieldType newFieldType = (FieldType)this.MemberwiseClone();
                newFieldType.fieldType = this.FieldTypeExpression.Freeze();
                newFieldType.ValidTypeExpression = false;
                return newFieldType;
            }
            return this;
        }
        #endregion

        // SSA

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

        internal TypeExpression Clone(IDictionary<int, TypeVariable> clonedTypeVariables, IList<EquivalenceClass> equivalenceClasses, MethodType methodAnalyzed, IDictionary<String, TypeExpression> evaluated)
        {
            if (!this.HasTypeVariables())
                return this;
            FieldType newFieldType = (FieldType)this.MemberwiseClone();            
            if (newFieldType.fieldType is ClassType)
                newFieldType.fieldType = ((ClassType)newFieldType.fieldType).Clone(clonedTypeVariables, equivalenceClasses, methodAnalyzed, evaluated);
            else if (newFieldType.fieldType != null)
                newFieldType.fieldType = newFieldType.fieldType.Clone(clonedTypeVariables, equivalenceClasses, methodAnalyzed);                            
            newFieldType.ValidTypeExpression = false;
            return newFieldType;
        }
        #endregion

        // Code Generation

        #region ILType()

        public override string ILType() {
            return this.fieldType.ILType();
        }

        #endregion

        #region IsValueType()

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

        #endregion


    }
}