ConstrainedDot.cs

Go to the documentation of this file.

using TypeSystem;
using AST;
using ErrorManagement;
using DynVarManagement;
using TypeSystem.Constraints;
using System.Collections.Generic;
//TODO: HAbrá que ver que se hace con StringtYPE, con el NULL
namespace TypeSystem.Operations {
    public class ConstrainedDotOperation : DotOperation {
        public override DotKind kindOfDot {
            get { return DotKind.Constrained; }
        }

        #region Fields
        protected string memberName;
        protected MethodType methodAnalyzed;
        protected IList<TypeExpression> previousDot;
        protected bool showErrorMessage;
        protected Location location;

        #endregion

        #region Constructors
        public ConstrainedDotOperation(string memberName, MethodType methodAnalyzed, IList<TypeExpression> previousDot, Location loc) {
            this.memberName = memberName;
            this.methodAnalyzed = methodAnalyzed;
            this.previousDot = previousDot; // * We only save the reference to promote throughput.
            this.location = loc;
        }

        #endregion

        #region arrayType.member

        public override object Exec(ArrayType d, object arg) {
            return d.AsClassType().AcceptOperation(this, arg);
        }
        #endregion

        #region BCLClassType.member
        public override object Exec(BCLClassType d, object arg) {
            TypeExpression member = (TypeExpression)d.AcceptOperation(new UnconstrainedDotOperation(this.memberName, this.previousDot), arg);
            if (member == null)
                ErrorManager.Instance.NotifyError(new UnknownMemberError(this.memberName, this.location));
            return member;
        }
        #endregion

        #region BoolType.member
        
        public override object Exec(BoolType d, object arg) {
            return d.AsClassType().AcceptOperation(this, arg);
        }
        #endregion

        #region CharType.member
        public override object Exec(CharType d, object arg) {
            return d.AsClassType().AcceptOperation(this, arg);
        }
        #endregion

        #region ClassType.member
        public override object Exec(ClassType d, object arg) {
            TypeExpression member = (TypeExpression)d.AcceptOperation(new UnconstrainedDotOperation(memberName, this.previousDot), arg);
            if (member == null) {
                ErrorManager.Instance.NotifyError(new UnknownMemberError(this.memberName, this.location));
                return null;
            }
            if (!d.validAccess(member)) {
                ErrorManager.Instance.NotifyError(new ProtectionLevelError(this.memberName, this.location));
                return null;
            }
            return member;
        }
        #endregion

        #region ClassTypeProxy.member
        public override object Exec(ClassTypeProxy d, object arg) {
            return d.RealType.AcceptOperation(this, arg);
        }
        #endregion

        #region Double.member
        public override object Exec(DoubleType d, object arg) {
            return d.AsClassType().AcceptOperation(this, arg);
        }
        #endregion

        #region FieldType.member

        public override object Exec(FieldType d, object arg) {
            if (d.FieldTypeExpression != null) {
                // * If the field type is a dynamic union type, so it is the union
                UnionType unionType = TypeExpression.As<UnionType>(d.FieldTypeExpression);
                if (unionType != null)
                    DynVarOptions.Instance.AssignDynamism(d.FieldTypeExpression, d.IsDynamic);
                return d.FieldTypeExpression.AcceptOperation(this, arg);
            }
            return null;
        }
        #endregion

        #region IntType.member
        public override object Exec(IntType d, object arg) {
            return d.AsClassType().AcceptOperation(this, arg);
        }
        #endregion

        #region Property.member
        public override object Exec(PropertyType d, object arg) {
            if (d.PropertyTypeExpression != null)
                return d.PropertyTypeExpression.AcceptOperation(this, arg);
            return null;
        }
        #endregion

        #region String.member
        public override object Exec(StringType d, object arg) {
            return d.AsClassType().AcceptOperation(this, arg);
        }
        #endregion

        #region TypeExpression.member
        public override object Exec(TypeExpression d, object arg) {
            return ReportError(d);
        }
        #endregion

        #region InterfaceType.member
        // Try to find the appropriate attribute
        public override object Exec(InterfaceType d, object arg) {
            UnconstrainedDotOperation uo = new UnconstrainedDotOperation(this.memberName, this.previousDot);
            TypeExpression member = (TypeExpression)d.AcceptOperation(uo, arg);
            if (member == null)
                // * Otherwise, error
                ErrorManager.Instance.NotifyError(new UnknownMemberError(this.memberName, this.location));
            return member;
        }

        #endregion

        #region TypeVariable.member
        public override object Exec(TypeVariable d, object arg) {
            if (d.Substitution != null) {
                DynVarOptions.Instance.AssignDynamism(d.Substitution, d.IsDynamic);
                return d.Substitution.AcceptOperation(this, arg);
            }
            if (methodAnalyzed != null) {
                // * A attribute access constraint is added to the method analyzed
                DotConstraint constraint = new DotConstraint(d, this.memberName, this.location);
                methodAnalyzed.AddConstraint(constraint);
                return constraint.ReturnType;
            }
            ErrorManager.Instance.NotifyError(new OperationNotAllowedError(".", d.FullName, this.location));
            return null;
        }
        #endregion

        #region UnionType.member
        public override object Exec(UnionType d, object arg) {
            // * Infinite loop detection
            if (previousDot.Contains(d))
                return new UnionType();
            previousDot.Add(d);

            // * If all the types in typeset generate a constraint, we simply generate one constraint using the whole union type
            if (d.IsFreshVariable() && methodAnalyzed != null) {
                // * A constraint is added to the method analyzed
                DotConstraint constraint = new DotConstraint(d, this.memberName, this.location);
                methodAnalyzed.AddConstraint(constraint);
                return constraint.ReturnType;
            }
            TypeExpression returnType = null;
            foreach (TypeExpression type in d.TypeSet) {
                TypeExpression ret;
                if (!d.IsDynamic) {
                    // * Static Behaviour: All the types must accept the attribute access
                    ret = (TypeExpression)type.AcceptOperation(this, arg);
                    if (ret == null) {
                        return null;
                    }
                } else
                    // * Dynamic Behaviour: Only one type must accept the attribute access
                    ret = (TypeExpression)type.AcceptOperation(new UnconstrainedDotOperation(this.memberName, previousDot), arg);
                if (ret != null)
                    returnType = UnionType.collect(returnType, ret);
            }
            // * If it is a dynamic union, one type must accept the attribute access
            if (returnType == null)
                ErrorManager.Instance.NotifyError(new NoTypeHasMember(d.FullName, this.memberName, this.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(".", tE.FullName, this.location));
            return null;
        }
        #endregion

    }
}