MethodType.cs

Go to the documentation of this file.

// -------------------------------------------------------------------------- //
// Project rROTOR                                                             //
// -------------------------------------------------------------------------- //
// File: MethodType.cs                                                        //
// Authors: Cristina Gonzalez Muñoz  -  cristi.gm@gmail.com                   //
//          Francisco Ortin - francisco.ortin@gmail.com                       //
// Description:                                                               //
//    Represents a method type.                                               //
//    Inheritance: MemberType.                                                //
//    Implements Composite pattern [Composite].                               //
//    Implements Observer pattern [Subject and Observer]                      //
// -------------------------------------------------------------------------- //
// Create date: 15-10-2006                                                    //
// Modification date: 03-04-2007                                              //
//visto
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;

using AST;
using ErrorManagement;
using TypeSystem.Constraints;
using Tools;
using TypeSystem.Operations;

namespace TypeSystem {
    public class MethodType : TypeExpression, IMemberType {
        #region Fields

        private TypeExpression ret;

        private List<TypeExpression> paramList = new List<TypeExpression>();

        private AccessModifier memberInfo;

        private ConstraintList constraints = new ConstraintList();

        private MethodDeclaration astNode;

        private int numberFreeVariablesCache;

        private bool validNumberFreeVariables;

        private bool isTypeInferred = false;

        private IDictionary<MethodType, TypeVariable> observerCollection;

        #endregion

        #region Properties

        public TypeExpression getParam (int index) {
            return paramList[index]; 
        }
        public TypeExpression Return {
            get { return this.ret; }
            set {
                this.ret = value;
                this.ValidTypeExpression = this.memberInfo.Class.ValidTypeExpression = false;
            }
        }

        public int ParameterListCount {
            get { return this.paramList.Count; }
        }

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

        public ConstraintList Constraints {
            get { return this.constraints; }
        }

        public MethodDeclaration ASTNode {
            get { return this.astNode; }
            set { this.astNode = value; }
        }

        internal override bool ValidTypeExpression {
            set {
                validTypeExpression = value;
                if (!value) {
                    // * Updates the full name
                    this.BuildFullName();
                    // * Recalculates its class type expression
                    if (this.MemberInfo != null && this.MemberInfo.Class != null)
                        this.MemberInfo.Class.ValidTypeExpression = false;
                }
            }
        }

        public bool IsTypeInferred {
            get { return this.isTypeInferred; }
        }
        #endregion

        #region Constructor

        public MethodType(TypeExpression ret) {
            this.ret = ret;
            this.BuildFullName();
        }
        #endregion

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

        #region AddParameter()
        public void AddParameter(TypeExpression paramType) {
            this.paramList.Add(paramType);
        }
        #endregion

        #region GetParameter()

        public TypeExpression GetParameter(int index) {
            if ((index >= 0) && (index < this.paramList.Count))
                return this.paramList[index];
            return null;
        }

        #endregion

        #region AddConstraint()
        public void AddConstraint(Constraint constraint) {
            //if (constraint is CloneConstraint)
            //{
            //    CloneConstraint cloneConstraint = ((CloneConstraint)constraint);
            //    foreach (var addedContraint in this.constraints.Constraints)
            //    {
            //        if (addedContraint is CloneConstraint)
            //        {
            //            CloneConstraint addedCloneConstraint = ((CloneConstraint)addedContraint);
            //            if (addedCloneConstraint.ReturnType.Equals(cloneConstraint.FirstOperand))
            //            {
            //                if (addedCloneConstraint.FirstOperand is TypeVariable && ((TypeVariable)addedCloneConstraint.FirstOperand).Substitution == null)
            //                {
            //                    this.constraints.Add(new CloneConstraint(addedCloneConstraint.FirstOperand));
            //                    return;
            //                }
            //            }
            //        }

            //    }
            //}
            this.constraints.Add(constraint);
        }
        #endregion

        #region AddConstraint()
        public void RemoveConstraint(int index) {
            this.constraints.Constraints.RemoveAt(index);
        }
        #endregion

        #region BuildTypeExpressionString()

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

            StringBuilder tE = new StringBuilder();
            // tE: Method(IdClass, IdMethod, mods, params -> ret)
            if (this.MemberInfo != null) {
                tE.AppendFormat("Method({0}, {1},", this.MemberInfo.Class.FullName, 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("(");
            if (this.paramList.Count > 0)
                for (int i = 0; i < this.paramList.Count; i++) {
                    tE.AppendFormat("{0}", this.paramList[i].BuildTypeExpressionString(depthLevel - 1));
                    if (i < this.paramList.Count - 1)
                        tE.Append(" x ");
                }
            else
                tE.Append("void");
            tE.Append(")->");
            if (this.ret != null)
                tE.Append(this.ret.BuildTypeExpressionString(depthLevel - 1));
            else
                tE.Append("void");
            // * Constraints
            tE.Append(", ");
            for (int i = 0; i < this.Constraints.Count; i++) {
                tE.Append(this.Constraints[i].ToString());
                if (i < this.Constraints.Count - 1)
                    tE.Append(" x ");
            }
            tE.Append(")");
            this.ValidTypeExpression = true;
            return this.typeExpression = tE.ToString();
        }
        #endregion

        #region BuildFullName()
        public override void BuildFullName() {
            StringBuilder fN = new StringBuilder();
            if (this.memberInfo != null)
                fN.AppendFormat("{0}.{1}:", this.MemberInfo.Class.FullName, this.MemberInfo.MemberIdentifier);
            fN.Append("(");
            if (this.paramList.Count > 0)
                for (int i = 0; i < this.paramList.Count; i++) {
                    fN.AppendFormat("{0}", this.paramList[i].FullName);
                    if (i < this.paramList.Count - 1)
                        fN.Append(" x ");
                }
            else fN.Append("void");
            fN.Append(")->");
            if (this.ret != null)
                fN.Append(this.ret.FullName);
            else fN.Append("void");
            fN.Append(")");
            this.fullName = fN.ToString();
        }
        #endregion

        // WriteType inference

        #region Parenthesis() ANULADA

        //public override TypeExpression Parenthesis(TypeExpression actualImplicitObject, TypeExpression[] arguments, MethodType methodAnalyzed,
        //                    SortOfUnification activeSortOfUnification, Location loc) {
        //    // * Quits if there's some error in the arguments
        //    if (arguments == null)
        //        return null;

        //    // * An instance method cannot be call from a static method without using an object
        //    if ((!this.MemberInfo.Modifiers.Contains(Modifier.Static)) && methodAnalyzed != null &&
        //        methodAnalyzed.MemberInfo.Modifiers.Contains(Modifier.Static) && actualImplicitObject == null) {
        //        ErrorManager.Instance.NotifyError(new InstanceMethodCallFromStaticMethodError(this.FullName, methodAnalyzed.FullName, loc));
        //        return null;
        //    }

        //    // * Is Unification necessary?
        //    if (this.MemberInfo.Class.HasTypeVariables() || this.HasTypeVariables())
        //        // * We infer the return type
        //        return methodCall(actualImplicitObject, this, arguments, methodAnalyzed, activeSortOfUnification, loc);

        //    // * Otherwise...
        //    // Check the argument number
        //    if (arguments.GetLength(0) != this.ParameterListCount) {
        //        ErrorManager.Instance.NotifyError(new ArgumentNumberError(this.MemberInfo.MemberIdentifier, arguments.GetLength(0), loc));
        //        return null;
        //    }
        //    // Check the argument type
        //    for (int i = 0; i < this.ParameterListCount; i++)
        //        arguments[i].Promotion(this.paramList[i], methodAnalyzed, loc);
        //    // * Returns the return type
        //    return this.ret;
        //}

        #endregion

        #region Equivalent()
        //public override bool Equivalent(TypeExpression type) {
        //    if (this == type)
        //        return true;
        //    TypeVariable typeVariable = type as TypeVariable;
        //    if (typeVariable != null)
        //        return typeVariable.Equivalent(this);
        //    MethodType method = type as MethodType;
        //    // * It must be a method
        //    if (method == null)
        //        return false;
        //    // * Same name
        //    if (!this.memberInfo.MemberIdentifier.Equals(method.memberInfo.MemberIdentifier))
        //        return false;
        //    // * Same class
        //    if (!this.MemberInfo.Class.Equivalent(method.MemberInfo.Class))
        //        return false;
        //    // * Same signature
        //    if (this.ParameterListCount != method.ParameterListCount)
        //        return false;
        //    for (int i = 0; i < this.ParameterListCount; i++)
        //        if (!this.GetParameter(i).Equivalent(method.GetParameter(i)))
        //            return false;
        //    return true;
        //}
        #endregion


        #region Promotion (Overloaded)

        public int Promotion(TypeExpression[] arguments, Location location) {
            int promotion = 0;
            int aux;

            // Has been any error in the arguments?
            if (arguments == null)
                return this.paramList.Count == 0 ? 0 : -1;

            // Check the argument number
            if (arguments.GetLength(0) != this.ParameterListCount)
                return -1;

            // Check the argument type
            for (int i = 0; i < this.ParameterListCount; i++) {
                if ((aux = (int)arguments[i].AcceptOperation( new PromotionLevelOperation(this.paramList[i]), null)) != -1)
                    promotion += aux;
                else
                    return -1;
            }
            return promotion;
        }

        #endregion

        #region EqualsForOverload() NO ANULADA
        public virtual bool EqualsForOverload(TypeExpression typeExpression) {
            return (bool) this.AcceptOperation(new EqualsForOverloadOperation(typeExpression), null);
        }
        #endregion

        #region GetNumberFreeVariables()
        public int GetNumberFreeVariables() {
            if (this.validNumberFreeVariables)
                return this.numberFreeVariablesCache;
            int number = 0;
            foreach (TypeExpression type in this.paramList)
                if (type.HasTypeVariables())
                    number++;
            this.validNumberFreeVariables = true;
            return this.numberFreeVariablesCache = number++;
        }
        #endregion

        // WriteType unification

        #region Unify
        public override bool Unify(TypeExpression te, SortOfUnification unification, IList<Pair<TypeExpression, TypeExpression>> previouslyUnified) {
            MethodType mt = te as MethodType;
            if (mt != null) {
                if (mt.ParameterListCount != this.ParameterListCount)
                    return false;
                bool success = true;
                for (int i = 0; i < this.ParameterListCount; i++)
                    if (!this.paramList[i].Unify(mt.GetParameter(i), unification, previouslyUnified)) {
                        success = false;
                        break;
                    }
                if (success)
                    success = this.Return.Unify(mt.Return, unification, previouslyUnified);
                // * 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);
            return false;
        }
        #endregion


        #region HasTypeVariables()
        public override bool HasTypeVariables() {
            if (this.validHasTypeVariables)
                return this.hasTypeVariablesCache;
            bool toReturn = this.ret.HasTypeVariables();
            if (!toReturn)
                foreach (TypeExpression type in this.paramList)
                    if (type.HasTypeVariables()) {
                        toReturn = true;
                        break;
                    }
            this.validHasTypeVariables = true;
            return this.hasTypeVariablesCache = toReturn;
        }
        #endregion

        #region CloneMethodType()
        public MethodType CloneMethodType(IDictionary<TypeVariable, TypeVariable> typeVariableMappings) {
            // * We clone the members of the MethodType
            MethodType methodType = new MethodType(null);
            List<TypeExpression> oldParameterList = this.paramList;
            methodType.paramList = new List<TypeExpression>();
            // * We must create new type variables for parameters
            IList<EquivalenceClass> equivalenceClasses = new List<EquivalenceClass>();
            for (int i = 0; i < this.paramList.Count; i++)
                // * Every type variable is cloned to a new one, adding both to typesVariables,
                //   inserting its equivalence classes in the equivalenceClasses parameter and updating the
                //   typeVariableMappings dictionary (<oldvariable,newVariable>
                methodType.paramList.Add(oldParameterList[i].CloneTypeVariables(typeVariableMappings, equivalenceClasses, new List<ClassType>()));
            // * The same for the returned value
            methodType.ret = this.ret.CloneTypeVariables(typeVariableMappings, equivalenceClasses, new List<ClassType>());
            // * Member info (access modifier)
            AccessModifier accessModifier = (AccessModifier)this.MemberInfo.Clone();
            accessModifier.Type = methodType;
            methodType.MemberInfo = accessModifier;
            // * We also have to clone the constraints
            methodType.constraints = (ConstraintList)this.constraints.CloneTypeVariables(typeVariableMappings, equivalenceClasses);
            // * For each equivalence class we create a new one, 
            //   substituting the old type variables for the new ones
            // * The substitution is not altered
            // * Since equivalence classes and type variables have a bidirectional association,
            //   the new equivalence classes will make type variables update their new equivalence classes
            foreach (EquivalenceClass equivalenceClass in equivalenceClasses)
                equivalenceClass.UpdateEquivalenceClass(typeVariableMappings);
            methodType.ValidTypeExpression = false;
            // * The new method type is returned
            return methodType;
        }
        #endregion

        // SSA

        #region Clone()
        internal override TypeExpression Clone(IDictionary<int, TypeVariable> clonedTypeVariables, IList<EquivalenceClass> equivalenceClasses, MethodType methodAnalyzed) {
            // * Methods are not cloned
            return this;
        }
        #endregion

        // Loop Detection

        // Helper Methods

        #region methodCall()

        public static TypeExpression methodCall(TypeExpression actualImplicitObject, MethodType formalMethod, TypeExpression[] args,
                  MethodType methodAnalyzed, SortOfUnification activeSortOfUnification, Location location) {
            UserType userType = formalMethod.MemberInfo.Class;
            MethodType actualMethod = null;
            // * We must create a new type with type variables for the object's attributes (the formal implicit object)
            IDictionary<TypeVariable, TypeVariable> typeVariableMappings = new Dictionary<TypeVariable, TypeVariable>();

            // * If the method is an instance one and the actual object is not this, we create a new implicit object to unify
            if (!formalMethod.MemberInfo.hasModifier(Modifier.Static) && actualImplicitObject != null && actualImplicitObject != methodAnalyzed.memberInfo.Class) {
                // * Unifies the implicit objects (actual and formal)
                UserType formalImplicitObject = (UserType)userType.CloneType(typeVariableMappings);
                if (!actualImplicitObject.Unify(formalImplicitObject, SortOfUnification.Equivalent, new List<Pair<TypeExpression, TypeExpression>>()))
                    // * If the formal implicit object already has substitution (fields declararion with assignments), we override it with a union type
                    formalImplicitObject.Unify(actualImplicitObject, SortOfUnification.Override, new List<Pair<TypeExpression, TypeExpression>>());
                actualImplicitObject.ValidTypeExpression = false;
            }

            // * If "this" is the actual implicit object, the return type is the original return type of the method
            TypeExpression originalReturnType = formalMethod.Return;

            if (formalMethod.HasTypeVariables() || formalMethod.Constraints.Count > 0)
                // * We must also generate a method with fresh variables (formal method)
                //   when it has parameters with type variables or constraints
                formalMethod = formalMethod.CloneMethodType(typeVariableMappings);

            // * If the method has type variables... 
            if (formalMethod.HasTypeVariables()) {
                // * We create the actual method:
                //   1.- The actual return type
                TypeVariable actualReturnType = TypeVariable.NewTypeVariable;
                //   2.- The actual method
                actualMethod = new MethodType(actualReturnType);
                //   3.- The actual parameters
                foreach (TypeExpression arg in args)
                    actualMethod.AddParameter(arg);

                // * Unifies both methods
                if (!actualMethod.Unify(formalMethod, SortOfUnification.Equivalent, new List<Pair<TypeExpression, TypeExpression>>())) {
                    ErrorManager.Instance.NotifyError(new UnificationError(actualMethod.FullName, location));
                    return null;
                }
            }
            // * Otherwise, arguments promotion must be checked
            else {
                if (args.Length != formalMethod.ParameterListCount) {
                    ErrorManager.Instance.NotifyError(new ArgumentNumberError(formalMethod.FullName, args.Length, location));
                    return null;
                }
                for (int i = 0; i < args.Length; i++)
                    if (args[i].AcceptOperation(PromotionOperation.Create(formalMethod.paramList[i], methodAnalyzed, location), null) == null)
                        return null;
            }

            // * Method constraints satisfaction            
            if (formalMethod.Constraints.Count > 0)
                formalMethod.Constraints.Check(methodAnalyzed, actualImplicitObject, true, activeSortOfUnification, location);


            // * The returned type is the the actual method if there has been a unification and
            //   in case the method is a instance method, a concrete object has been used (not this) or 
            //   a different implicit object (the this reference is changed in the SSA algorithm)
            if (actualMethod != null && (formalMethod.MemberInfo.hasModifier(Modifier.Static) ||
                                         ClassType.IsConcreteType(actualImplicitObject) != null ||
                                         actualImplicitObject != formalMethod.MemberInfo.Class)) {
                TypeVariable returnType = (TypeVariable)actualMethod.Return;
                if (returnType.Substitution != null)
                    return returnType.EquivalenceClass.Substitution;
                return returnType;
            }
            // * The original returned type if there has been no unification or the implicit object is "this"
            return originalReturnType;
        }

        #endregion

        #region AddInferredTypeObserver()

        public void addInferredTypeObserver(MethodType method, TypeVariable returnType) {
            if (this.observerCollection == null)
                this.observerCollection = new Dictionary<MethodType, TypeVariable>();
            this.observerCollection[method] = returnType;
        }

        #endregion

        #region TypeInferred()

        public void TypeInferred() {
            this.isTypeInferred = true;
            // * Iterates through all the observers, updating the new type inferred
            if (this.observerCollection != null) {
                foreach (KeyValuePair<MethodType, TypeVariable> pair in this.observerCollection) {
                    // * Once the type is inferred, we add it to the caller (the observer)
                    pair.Key.Return = UnionType.collect(pair.Key.Return, this.Return);
                    // * The type variable used for the return type in the method call is unified
                    //   with the actual type (once inferred), excluding itself
                    this.Return.Remove(pair.Value);
                    //if (pair.Key.Return is TypeVariable)
                    //  this.Return.Remove((TypeVariable)pair.Key.Return);
                    pair.Value.Unify(this.Return, SortOfUnification.Equivalent, new List<Pair<TypeExpression, TypeExpression>>());
                }
            }
        }

        #endregion

        #region IsValueType()

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

        #endregion

    }
}