AssignmentOperation.cs

Go to the documentation of this file.

using System;
using TypeSystem.Operations;
using TypeSystem;
using ErrorManagement;
using AST;
using Tools;
using System.Collections.Generic;
using TypeSystem.Constraints;
namespace TypeSystem.Operations {
    public class AssignmentOperation : TypeSystemOperation {
        protected TypeExpression rightOperand;
        protected AssignmentOperator op;
        protected MethodType methodAnalyzed;
        protected SortOfUnification unification;
        protected TypeExpression actualImplicitObject;
        protected Location location;

        #region Constructor
        public AssignmentOperation(TypeExpression rightOperand, AssignmentOperator op, MethodType methodAnalyzed, SortOfUnification unification, TypeExpression actualImplicitObject, Location location) {
            this.rightOperand = rightOperand;
            this.op = op;
            this.methodAnalyzed = methodAnalyzed;
            this.unification = unification;
            this.actualImplicitObject = actualImplicitObject;
            this.location = location;
        }
        #endregion

        #region Array = ...
        public override object Exec(ArrayType leftOperand, object arg) {

            if (this.op == AssignmentOperator.Assign && (bool)this.rightOperand.AcceptOperation(new EquivalentOperation(leftOperand), arg)) {
                if (!leftOperand.HasTypeVariables())
                    return leftOperand;
                // * Unification, meter una ternaria aqúi? igual muy queda la linea muy grande
                if (leftOperand.Unify(this.rightOperand, this.unification, new List<Pair<TypeExpression, TypeExpression>>()))
                    return leftOperand;
                else
                    return ReportError(leftOperand);
            }
            return ReportError(leftOperand);
        }

        #endregion

        #region Bool = ...
        public override object Exec(BoolType leftOperand, object arg) {
            return this.op == AssignmentOperator.Assign // * if the operator is not assing raise and error, in other case, check if the second operand can be promotable to a BoolType
                ? rightOperand.AcceptOperation(PromotionOperation.Create(leftOperand, this.op, this.methodAnalyzed, this.location), arg)
                : ReportError(leftOperand);
        }

        #endregion


        #region Class = ...
        public override object Exec(ClassType leftOperand, object arg) { // the unique allowable operator
            if (this.op == AssignmentOperator.Assign) {
                if ( this.rightOperand.AcceptOperation(PromotionOperation.Create(leftOperand, this.op, this.methodAnalyzed, this.location), arg) == null )
                    return null;
                if (!leftOperand.HasTypeVariables())
                    return leftOperand;
                // * If the left expression of the assignment has type variables, 
                //   we must return the concrete type (not the abstract one)
                // * Then whe unify the concrete types
                FieldType fieldType = TypeExpression.As<FieldType>(this.rightOperand);
                if (fieldType != null)
                    this.rightOperand = fieldType.FieldTypeExpression;
                if (leftOperand.Unify(this.rightOperand, this.unification, new List<Pair<TypeExpression, TypeExpression>>())) {
                    leftOperand.ValidTypeExpression = false;
                    return leftOperand;
                }
            }
            ErrorManager.Instance.NotifyError(new OperationNotAllowedError(this.op.ToString(), leftOperand.FullName, rightOperand.FullName, this.location));
            return null;

        }

        #endregion

        #region ClassTypeProxy = ...
        public override object Exec(ClassTypeProxy leftOperand, object arg) {
            return leftOperand.RealType.AcceptOperation(this, arg);
        }

        #endregion

        #region Char = ...
        public override object Exec(CharType leftOperand, object arg) {

            return rightOperand.AcceptOperation(PromotionOperation.Create(leftOperand, this.op, this.methodAnalyzed, this.location), arg);
        }

        #endregion
        #region Double = ...

        public override object Exec(DoubleType leftOperand, object arg) {

            return rightOperand.AcceptOperation(PromotionOperation.Create(leftOperand, this.op, this.methodAnalyzed, this.location), arg);
        }

        #endregion

        #region FieldType = ...
        public override object Exec(FieldType leftOperand, object arg) {
           
            // * 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 (leftOperand.HasTypeVariables() && this.methodAnalyzed != null &&
                ClassType.IsConcreteType(this.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) this.methodAnalyzed.MemberInfo.Class;
                while (!(found = (leftOperand.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 = leftOperand;
                    ClassType thisType = TypeExpression.As<ClassType>(this.actualImplicitObject);
                    if (thisType == null)
                    {
                        FieldType field = TypeExpression.As<FieldType>(this.actualImplicitObject);
                        if (field != null)
                            thisType = TypeExpression.As<ClassType>(field.FieldTypeExpression);
                    }
                       
                    if (thisType != null)
                    {
                        while (thisType != null && !thisType.Fields.ContainsKey(leftOperand.MemberInfo.MemberIdentifier))
                        {
                            thisType = thisType.BaseClass;
                        }
                        if (thisType != null)
                            fieldType = (FieldType) thisType.Fields[leftOperand.MemberInfo.MemberIdentifier].Type;
                    }
                       
                    this.methodAnalyzed.AddConstraint(new FieldTypeAssignmentConstraint(fieldType, this.rightOperand,
                                                                                        this.unification));
                    this.methodAnalyzed.ValidTypeExpression = false;
                    if (leftOperand.FieldTypeExpression is TypeVariable && rightOperand is ArrayType)
                    {
                        TypeVariable typeVariable = (TypeVariable)leftOperand.FieldTypeExpression;
                        typeVariable.AcceptOperation(new AssignmentOperation(rightOperand, this.op, null, SortOfUnification.Override, null, this.location), arg);
                    }
                    else if (leftOperand.FieldTypeExpression is TypeVariable && rightOperand is TypeVariable && ((TypeVariable)rightOperand).Substitution == null && ((TypeVariable)rightOperand).IsDynamic)
                    {
                        TypeVariable typeVariable = (TypeVariable)leftOperand.FieldTypeExpression;
                        typeVariable.AcceptOperation(new AssignmentOperation(rightOperand, this.op, null, SortOfUnification.Override, null, this.location), arg);
                    }
                    return leftOperand.FieldTypeExpression;
                }
                if (leftOperand.FieldTypeExpression is TypeVariable)
                {
                    TypeVariable typeVariable = (TypeVariable) leftOperand.FieldTypeExpression;
                    if (typeVariable.Substitution != null)
                    {
                        return
                            leftOperand.FieldTypeExpression.AcceptOperation(
                                new AssignmentOperation(this.rightOperand, this.op, null,
                                                        SortOfUnification.Incremental, this.actualImplicitObject,
                                                        this.location), arg);
                    }
                }
            }

            if (leftOperand.FieldTypeExpression != null)
                return
                    leftOperand.FieldTypeExpression.AcceptOperation(
                        new AssignmentOperation(this.rightOperand, this.op, null, this.unification,
                                                this.actualImplicitObject, this.location), arg);

            return null;                     
        }

        #endregion

        #region InterfaceType = ...
        public override object Exec(InterfaceType leftOperand, object arg) {
            if (this.op == AssignmentOperator.Assign)
                return rightOperand.AcceptOperation(PromotionOperation.Create(leftOperand, this.op, this.methodAnalyzed, this.location), arg);

            return ReportError(leftOperand);
        }
        #endregion

        public override object Exec(IntType leftOperand, object arg) {
            return rightOperand.AcceptOperation(PromotionOperation.Create(leftOperand, this.op, this.methodAnalyzed, this.location), arg);
        }


        #region NullType = ...
        public override object Exec(NullType leftOperand, object arg) {
            return op == AssignmentOperator.Assign ? this.rightOperand : ReportError(leftOperand);
        }
        #endregion


        #region PropertyType = ...
        public override object Exec(PropertyType leftOperand, object arg) {
            if (!leftOperand.MemberInfo.hasModifier(Modifier.CanWrite)) {
                ErrorManager.Instance.NotifyError(new PropertyWriteError(leftOperand.MemberInfo.MemberIdentifier, this.location));
                return null;
            }
            if (leftOperand.PropertyTypeExpression != null)
                return leftOperand.PropertyTypeExpression.AcceptOperation(new AssignmentOperation(this.rightOperand, this.op, null, this.unification, this.actualImplicitObject, this.location), arg);

            return null;
        }

        #endregion


        #region StringType = ...
        public override object Exec(StringType leftOperand, object arg) {
            if (op == AssignmentOperator.Assign || op == AssignmentOperator.PlusAssign)
                return rightOperand.AcceptOperation(PromotionOperation.Create(leftOperand, this.op, this.methodAnalyzed, this.location), arg);
            // * se podría aquí hacer un base.ReportError()?;
            ErrorManager.Instance.NotifyError(new OperationNotAllowedError(leftOperand.FullName, rightOperand.FullName, this.location));
            return null;
        }

        #endregion


        #region TypeExpression  = ...

        public override object Exec(TypeExpression leftOperand, object arg) {
            return ReportError(leftOperand);
        }


        #endregion

        #region TypeVariable = ...
        public override object Exec(TypeVariable leftOperand, object arg) {
            // * Bounded variable?
            if (leftOperand.Substitution != null && this.unification == SortOfUnification.Equivalent)
                // * Check promotion to its substitution
                return rightOperand.AcceptOperation(PromotionOperation.Create(leftOperand, this.op, this.methodAnalyzed, this.location), arg);
            // * If the variable its not bounded, we add the parameter to the equivalence list
            if (leftOperand.addToMyEquivalenceClass(rightOperand, this.unification, new List<Pair<TypeExpression, TypeExpression>>()))
                return leftOperand;
            // * If it has not been possible, error
            ErrorManager.Instance.NotifyError(new OperationNotAllowedError(this.op.ToString(), leftOperand.FullName, rightOperand.FullName, this.location));
            return null;
        }


        #endregion

        #region UnionType = ...
        public override object Exec(UnionType leftOperand, object arg) {
            // * If the unification is incremental, we must add it to the union typeset
            if (this.unification == SortOfUnification.Incremental) {
                leftOperand.TypeSet.Add(rightOperand);
                return leftOperand;
            }
            foreach (TypeExpression type in leftOperand.TypeSet)
                if ((int)rightOperand.AcceptOperation(new PromotionLevelOperation(type), arg) == -1)
                    return ReportError(leftOperand);

            return leftOperand;
        }

        public override object ReportError(TypeExpression tE) {
            ErrorManager.Instance.NotifyError(new AssignmentError(rightOperand.FullName, tE.FullName, this.location));
            return null; ;
        }
        #endregion
    }

}