PropertyType.cs

Go to the documentation of this file.

// -------------------------------------------------------------------------- //
// Project rROTOR                                                             //
// -------------------------------------------------------------------------- //
// File: PropertyType.cs                                                      //
// Author: Cristina Gonzalez Muñoz  -  cristi.gm@gmail.com                    //
// Description:                                                               //
//    Represents a property type.                                             //
//    Inheritance: MemberType.                                                //
//    Implements Composite pattern [Composite].                               //
// -------------------------------------------------------------------------- //
// Create date: 16-03-2007                                                    //
// Modification date: 29-03-2007                                              //

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

using AST;
using ErrorManagement;
using Tools;
using TypeSystem.Operations;
//VISTO
namespace TypeSystem {
    public class PropertyType : TypeExpression, IMemberType {
        #region Fields

        private TypeExpression propertyType;

        private bool setAccess;

        private bool getAccess;

        private AccessModifier memberInfo;

        #endregion

        #region Properties

        public TypeExpression PropertyTypeExpression {
            get { return this.propertyType; }
        }

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

        #endregion

        #region Constructor

        public PropertyType(TypeExpression type, bool canRead, bool canWrite) {
            this.propertyType = type;
            this.getAccess = canRead;
            this.setAccess = canWrite;
            this.BuildFullName();
        }

        #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.propertyType == null)
                return "null";
            this.fullName = this.propertyType.FullName;

            StringBuilder tE = new StringBuilder();
            // tE: Property(IdClass, IdProperty, mods, type)
            tE.AppendFormat("Property({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.propertyType.BuildTypeExpressionString(depthLevel-1));
            tE.Append(")");
            this.ValidTypeExpression = true;
            return this.typeExpression=tE.ToString();
        }
        #endregion

        #region BuildFullName()
        public override void BuildFullName() {
            if (this.MemberInfo != null)
                this.fullName = String.Format("{0}.{1}:{2}", this.MemberInfo.Class.FullName,
                    this.MemberInfo.MemberIdentifier, this.propertyType.FullName);
            else
                this.fullName = this.propertyType.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 (propertyType != null)
        //        return this.propertyType.Dot(field, methodAnalyzed, previousDot, loc);
        //    return null;
        //}
        //public override TypeExpression Dot(string memberName, IList<TypeExpression> previousDot) {
        //    if (propertyType != null)
        //        return this.propertyType.Dot(memberName, previousDot);
        //    return null;
        //}
        #endregion

        #region Bracket() ANULADA

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

        #endregion

        #region Assignment() ANULADA

        //public override TypeExpression Assignment(TypeExpression operand, AssignmentOperator op, MethodType methodOrClassAnalyzed, SortOfUnification unification, 
        //            TypeExpression actualImplicitObject, Location location) {
        //    if (!this.MemberInfo.hasModifier(Modifier.CanWrite)) {
        //        ErrorManager.Instance.NotifyError(new PropertyWriteError(this.MemberInfo.MemberIdentifier, location));
        //        return null;
        //    }
        //    if (this.propertyType != null)
        //        return this.propertyType.Assignment(operand, op, null, unification, actualImplicitObject, location);
        //    return null;
        //}

        #endregion

        #region Arithmetic() ANULADA
        /*

        public override TypeExpression Arithmetic(TypeExpression operand, Enum op, MethodType methodAnalyzed, bool showErrorMessage, Location loc) {
            if (propertyType != null)
                return this.propertyType.Arithmetic(operand, op, methodAnalyzed, showErrorMessage, loc);
            return null;
        }

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

        #region Relational() ANULADA
        /*

        public override TypeExpression Relational(TypeExpression operand, RelationalOperator op, MethodType methodAnalyzed, bool showErrorMessage, Location loc) {
            if (propertyType != null)
                return this.propertyType.Relational(operand, op, methodAnalyzed, showErrorMessage, loc);
            return null;
        }
        */
        #endregion

        // WriteType Promotion

        #region PromotionLevel() ANULADA
        //public override int PromotionLevel(TypeExpression type) {
        //    if (propertyType != null)
        //        return this.propertyType.PromotionLevel(type);
        //    return -1;
        //}

        #endregion


        // WriteType Unification

        #region Unify
        public override bool Unify(TypeExpression te, SortOfUnification unification, IList<Pair<TypeExpression, TypeExpression>> previouslyUnified) {
            // * Clears the type expression cache
            this.ValidTypeExpression = false;
            te.ValidTypeExpression = false;
            // TODO (not implemented yet; it is not possible to define var properties)
            return false;
        }
        #endregion

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

        }
        #endregion

        // SSA

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

        // Code Generation

        #region ILType()

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

        #endregion

        #region IsValueType()

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

        #endregion


    }
}