BinaryArithmeticalOperation.cs

Go to the documentation of this file.

using TypeSystem;
using AST;
using ErrorManagement;
using System;
using DynVarManagement;
using TypeSystem.Constraints;
namespace TypeSystem.Operations {
    public class BinaryArithmeticalOperation : ArithmeticalOperation {
        #region Fields
        protected TypeExpression secondOperand;
         protected Enum binaryOperator;
        protected MethodType methodAnalyzed;
        protected bool showErrorMessage; 
        protected Location location;
        #endregion

        #region Constructor
        public BinaryArithmeticalOperation(TypeExpression secondOperand, Enum binaryOperator, MethodType methodAnalyzed, bool showErrorMessage, Location location) {

            this.secondOperand = secondOperand;
            this.binaryOperator = binaryOperator;
            this.methodAnalyzed = methodAnalyzed;
            this.showErrorMessage = showErrorMessage;
            this.location = location;
        }
        #endregion
 
        #region BoolType +-secondOperand
        public override object Exec(BoolType firstOperand, object arg) {
            if (this.binaryOperator.Equals(ArithmeticOperator.Plus) && (bool)this.secondOperand.AcceptOperation(new EquivalentOperation(StringType.Instance), arg))
                return StringType.Instance;
            if (this.showErrorMessage) //TODO: REvisar ESta SIgnaTURA
                ErrorManager.Instance.NotifyError(new TypePromotionError(firstOperand.FullName, this.secondOperand.FullName, this.binaryOperator.ToString(), this.location));
            return null;
        }
        #endregion

        #region DoubleType +-secondOperand
        public override object Exec(DoubleType firstOperand, object arg) {
            if ((int)this.secondOperand.AcceptOperation(new PromotionLevelOperation(firstOperand), arg) != -1)
            {                 
                if (secondOperand is TypeVariable)
                {
                    if (methodAnalyzed != null && ((TypeVariable)secondOperand).Substitution == null)
                    {
                        // * A constraint is added to the method analyzed                        
                        ArithmeticConstraint constraint = new ArithmeticConstraint(firstOperand, secondOperand, binaryOperator, location);                            
                        methodAnalyzed.AddConstraint(constraint);
                        return constraint.ReturnType;
                    }
                }
                return DoubleType.Instance;
            }                
            if (this.binaryOperator.Equals(ArithmeticOperator.Plus) && (bool)this.secondOperand.AcceptOperation(new EquivalentOperation(StringType.Instance), arg))
                return StringType.Instance;
            // We rely in arithmetic conmutativiness to perform a cross recursion. Could it be dangerous?
            return secondOperand.AcceptOperation(ArithmeticalOperation.Create(firstOperand, this.binaryOperator, this.methodAnalyzed, this.showErrorMessage, this.location), arg);
        }
        #endregion

        #region IntType +-secondOperand
        public override object Exec(IntType firstOperand, object arg) {
            if ((int)this.secondOperand.AcceptOperation(new PromotionLevelOperation(firstOperand), arg) != -1)
            {
                if (secondOperand is TypeVariable && ((TypeVariable) secondOperand).Substitution == null)
                {
                    if (methodAnalyzed != null)
                    {
                        // * A constraint is added to the method analyzed
                        ArithmeticConstraint constraint = new ArithmeticConstraint(firstOperand, secondOperand,
                                                                                   binaryOperator, location);
                        methodAnalyzed.AddConstraint(constraint);
                        return constraint.ReturnType;
                    }
                }
                return IntType.Instance;
            }
            if (this.binaryOperator.Equals(ArithmeticOperator.Plus) && (bool)this.secondOperand.AcceptOperation(new EquivalentOperation(StringType.Instance), arg))
                return StringType.Instance;
            return this.secondOperand.AcceptOperation(ArithmeticalOperation.Create(firstOperand, this.binaryOperator, this.methodAnalyzed, this.showErrorMessage, this.location), arg);
        }
        #endregion

        #region CharType +-secondOperand
        public override object Exec(CharType firstOperand, object arg) {
            if ((int)this.secondOperand.AcceptOperation(new PromotionLevelOperation(firstOperand), arg) != -1)
            {
                if (secondOperand is TypeVariable && ((TypeVariable)secondOperand).Substitution == null)
                {
                    if (methodAnalyzed != null)
                    {
                        // * A constraint is added to the method analyzed
                        ArithmeticConstraint constraint = new ArithmeticConstraint(firstOperand, secondOperand,
                                                                                   binaryOperator, location);
                        methodAnalyzed.AddConstraint(constraint);
                        return constraint.ReturnType;
                    }
                }
                return IntType.Instance;
            }
            if (this.binaryOperator.Equals(ArithmeticOperator.Plus) && (bool)this.secondOperand.AcceptOperation(new EquivalentOperation(StringType.Instance), arg))
                return StringType.Instance;
            return this.secondOperand.AcceptOperation(ArithmeticalOperation.Create(firstOperand, this.binaryOperator, this.methodAnalyzed, this.showErrorMessage, this.location), arg);
        }
        #endregion

        #region StringType +-secondOperand
        
        //TODO: en la versión original, en vez de promotable to a string se preguntaba por string
        public override object Exec(StringType firstOperand, object arg) {
            if (binaryOperator.Equals(ArithmeticOperator.Plus)) {
                if (promotableToStringInAddition(this.secondOperand))
                    return StringType.Instance;

                // * Commutative
                return secondOperand.AcceptOperation(ArithmeticalOperation.Create(firstOperand, this.binaryOperator, this.methodAnalyzed, this.showErrorMessage, this.location), arg);
            }
            return ReportError(firstOperand);
        }
        #endregion

        #region
        protected bool promotableToStringInAddition(TypeExpression tE) {
            return (int)tE.AcceptOperation(new PromotionLevelOperation(DoubleType.Instance), null) != -1
               || (bool)tE.AcceptOperation(new EquivalentOperation(CharType.Instance), null)
               || (bool)tE.AcceptOperation(new EquivalentOperation(StringType.Instance), null)
               || (bool)tE.AcceptOperation(new EquivalentOperation(NullType.Instance), null);

        }
        #endregion

        #region NullType +-secondOperand
        public override object Exec(NullType firstOperand, object arg) {
            if (this.binaryOperator.Equals(ArithmeticOperator.Plus) && (bool)this.secondOperand.AcceptOperation(new EquivalentOperation(StringType.Instance), arg))
                return StringType.Instance;
            if (showErrorMessage)
                ErrorManager.Instance.NotifyError(new TypePromotionError(this.secondOperand.FullName, firstOperand.FullName, this.binaryOperator.ToString(), this.location));
            return null;
        }
        #endregion

        #region FieldType +-secondOperand
        public override object Exec(FieldType firstOperand, object arg) {
            if (firstOperand.FieldTypeExpression != null)
                return firstOperand.FieldTypeExpression.AcceptOperation(this, arg);
            return null;
        }
        #endregion

        #region PropertyType +-secondOperand
        public override object Exec(PropertyType firstOperand, object arg) {
            if (firstOperand.PropertyTypeExpression != null)
                return firstOperand.PropertyTypeExpression.AcceptOperation(ArithmeticalOperation.Create(firstOperand, this.binaryOperator, this.methodAnalyzed, this.showErrorMessage, this.location), arg);
            return null;

        }
        #endregion

        #region TypeVariable +-secondOperand
        public override object Exec(TypeVariable firstOperand, object arg) {
            if (firstOperand.Substitution != null) {
                DynVarOptions.Instance.AssignDynamism(firstOperand.Substitution, firstOperand.IsDynamic);
                return firstOperand.Substitution.AcceptOperation(this, arg);
            }
            if (methodAnalyzed != null) {
                // * A constraint is added to the method analyzed
                ArithmeticConstraint constraint = new ArithmeticConstraint(firstOperand, secondOperand, binaryOperator, location);
                methodAnalyzed.AddConstraint(constraint);
                return constraint.ReturnType;
            }
            if (showErrorMessage)
                ErrorManager.Instance.NotifyError(new OperationNotAllowedError(binaryOperator.ToString(), firstOperand.FullName, secondOperand.FullName, location));

            return null;
        }
        #endregion

        #region UnionType +-secondOperand
        public override object Exec(UnionType firstOperand, object arg) {
            // * If all the types in typeset generate a constraint, we simply generate one constraint using the whole union type
            if (firstOperand.IsFreshVariable() && methodAnalyzed != null) {
                // * A constraint is added to the method analyzed
                ArithmeticConstraint constraint = new ArithmeticConstraint(firstOperand, secondOperand, binaryOperator, location);
                methodAnalyzed.AddConstraint(constraint);
                return constraint.ReturnType;
            }
            TypeExpression returnType = null;
            foreach (TypeExpression type in firstOperand.TypeSet) {
                TypeExpression ret = (TypeExpression)type.AcceptOperation(ArithmeticalOperation.Create(secondOperand, binaryOperator, methodAnalyzed, !firstOperand.IsDynamic && showErrorMessage, location), arg);
                if (ret == null && !firstOperand.IsDynamic)
                    return null;
                if (ret != null)
                    returnType = UnionType.collect(returnType, ret);
            }
            // * If there has been some errors, they have not been shown because the type is dynamic, we show it
            if (showErrorMessage && firstOperand.IsDynamic && returnType == null)
                ErrorManager.Instance.NotifyError(new NoTypeAcceptsOperation(firstOperand.FullName, this.binaryOperator.ToString(), secondOperand.FullName, location));
            return returnType;
        }
        #endregion

        #region Report Errors

        // in our case we only notify operations not allowed
        // for other pruposes invoke explicitly another kind of error
        
        public override object ReportError(TypeExpression tE) {
            if (this.showErrorMessage)
                ErrorManager.Instance.NotifyError(new OperationNotAllowedError(this.binaryOperator.ToString(), tE.FullName, this.secondOperand.FullName, this.location));
            return null;
        }
        #endregion

    }
}