PromotionConstraint.cs

Go to the documentation of this file.

// -------------------------------------------------------------------------- 
// Project rROTOR                                                             
// -------------------------------------------------------------------------- 
// File: PromotionConstraint.cs                                                    
// Author:  Francisco Ortin - francisco.ortin@gmail.com                       
// Description:                                                               
//    Promotion constraint to be executed each time the associated method
//       has been called. It represents constraints of the form:
//                 op1 <= op2 (op1 is a subtype of op2)
//    Implements Composite pattern [Leaf].                               
//    Implements Command pattern [Concrete Command].                               
//    Implements Memento pattern [Memento].                               
// -------------------------------------------------------------------------- 
// Create date: 05-04-2007                                                    
// Modification date: 25-04-2007                                              

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

using ErrorManagement;
using TypeSystem.Operations;

namespace TypeSystem.Constraints {
    class PromotionConstraint : ConstraintAdapter {
        #region Fields
        private TypeExpression secondOperand;

        private object op;
        #endregion

        #region Properties
        public TypeExpression SecondOperand {
            get { return this.secondOperand; }
        }

        public object Operator {
            get { return this.op; }
        }
        #endregion


        #region Constructor
        public PromotionConstraint(TypeExpression firstOperand, TypeExpression secondOperand, object op, Location location)
            : base(firstOperand, location) {
            this.secondOperand = secondOperand;
            this.op = op;
        }
        public PromotionConstraint(TypeExpression firstOperand, TypeExpression secondOperand, Location location)
            : this(firstOperand, secondOperand, null, location) { }
        #endregion

        #region BuildTypeExpressionString()
        protected override string BuildTypeExpressionString() {
            return String.Format("{0} <= {1}", this.FirstOperand.FullName, this.SecondOperand.FullName);
        }
        #endregion

        #region EqualsAndGetHashCode
        public override bool Equals(object obj) {
            PromotionConstraint constraint = obj as PromotionConstraint;
            if (constraint == null)
                return false;
            return this.FirstOperand.Equals(constraint.FirstOperand) && this.secondOperand.Equals(constraint.secondOperand);
        }
        public override int GetHashCode() {
            return this.FirstOperand.GetHashCode()*this.secondOperand.GetHashCode();
        }
        #endregion


        #region CloneTypeVariables()
        public override Constraint CloneTypeVariables(IDictionary<TypeVariable, TypeVariable> typeVariableMappings, IList<EquivalenceClass> equivalenceClasses) {
            TypeExpression newFirstOperand = this.FirstOperand.CloneTypeVariables(typeVariableMappings, equivalenceClasses, new List<ClassType>()),
                newSecondOperand = this.SecondOperand.CloneTypeVariables(typeVariableMappings, equivalenceClasses, new List<ClassType>());
            if (this.op != null)
                return new PromotionConstraint(newFirstOperand, newSecondOperand, this.Operator, this.Location);
            return new PromotionConstraint(newFirstOperand, newSecondOperand, this.Location);
        }
        #endregion

        #region Check()
        public override TypeExpression Check(MethodType methodAnalyzed, TypeExpression actualImplicitObject, bool showInvocationMessage,
                            SortOfUnification activeSortOfUnification, Location location) {
            TypeExpression result;
            if (this.op!=null)
                //result = this.FirstOperand.Promotion(this.SecondOperand, (Enum)this.Operator, methodAnalyzed, this.Location);
                result = (TypeExpression)this.FirstOperand.AcceptOperation(PromotionOperation.Create(this.SecondOperand, (Enum)this.Operator, methodAnalyzed, this.Location), null);
            else
                result = (TypeExpression)this.FirstOperand.AcceptOperation(PromotionOperation.Create(this.SecondOperand, methodAnalyzed, this.Location), null);
            if (result == null && showInvocationMessage) {
                ErrorManager.Instance.NotifyError(new ConstraintError(location));
                return null;
            }
            // * If no error exists, we return the supertype
            return this.SecondOperand;
        }
        #endregion


    }
}