NullType.cs

Go to the documentation of this file.

// -------------------------------------------------------------------------- //
// Project rROTOR                                                             //
// -------------------------------------------------------------------------- //
// File: NullType.cs                                                          //
// Authors: Cristina Gonzalez Muñoz  -  cristi.gm@gmail.com                   //
//          Francisco Ortin - francisco.ortin@gmail.com                       //
// Description:                                                               //
//    Represent a null type.                                                  //
//    Inheritance: TypeExpression.                                            //
//    Implements Composite pattern [Leaf].                                    //
//    Implements Singleton pattern.                                           //
// -------------------------------------------------------------------------- //
// Create date: 05-04-2007                                                    //
// Modification date: 05-04-2007                                              //
//VISTO
using System;
using System.Collections.Generic;
using System.Text;

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

namespace TypeSystem {
    public class NullType : TypeExpression {
        
        #region Fields

        private static readonly NullType instance = new NullType();

        #endregion

        #region Properties

        public static NullType Instance {
            get { return instance; }
        }

        #endregion

        #region Constructors

        private NullType() {
            this.typeExpression = "null";
            this.fullName = "null";
        }

        static NullType() {
        }

        #endregion

        // WriteType Inference

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

        #region Assignment() ANULADA

        //public override TypeExpression Assignment(TypeExpression operand, AssignmentOperator op, MethodType methodAnalyzed, SortOfUnification unification,
        //            TypeExpression actualImplicitObject, Location location) {
        //    if (op == AssignmentOperator.Assign)
        //        return operand;
        //    else
        //        ErrorManager.Instance.NotifyError(new AssignmentError(operand.FullName, this.FullName, location));
        //    return null;
        //}
        #endregion

        #region Arithmetic() ANULADA
        /*
        public override TypeExpression Arithmetic(TypeExpression operand, Enum op, MethodType methodAnalyzed, bool showErrorMessage, Location loc) {
            if (op.Equals(ArithmeticOperator.Plus) && operand.Equivalent(StringType.Instance))
                return StringType.Instance;
            if (showErrorMessage)
                ErrorManager.Instance.NotifyError(new TypePromotionError(operand.FullName, this.FullName, op.ToString(), loc));
            return null;
        } */
        #endregion

        // WriteType Promotion

        #region PromotionLevel() ANULADA

        //public override int PromotionLevel(TypeExpression type) {
        //    // * Built-in types: no promotion, except string
        //    if (type is BoolType || type is CharType || type is DoubleType || type is IntType || type is VoidType)
        //        return -1;
        //    // * BCL Value Types (structs): No promotion
        //    BCLClassType bclClass = TypeExpression.As<BCLClassType>(type);
        //    if (bclClass != null) {
        //        if (bclClass.TypeInfo.IsValueType)
        //            return -1;
        //        // * Correct promotion to classes that are not value types
        //        return 0;
        //    }
        //    // * WriteType variable
        //    TypeVariable typeVariable = type as TypeVariable;
        //    if (typeVariable != null) {
        //        if (typeVariable.Substitution != null)
        //            // * If the variable is bounded, the promotion is the one of its substitution
        //            return this.PromotionLevel(typeVariable.EquivalenceClass.Substitution);
        //        // * A free variable is complete promotion
        //        return 0;
        //    }
        //    // * Union type
        //    UnionType unionType = TypeExpression.As<UnionType>(type);
        //    if (unionType != null)
        //        return unionType.SuperType(this);
        //    // * Field type and bounded type variable
        //    FieldType fieldType = TypeExpression.As<FieldType>(type);
        //    if (fieldType != null)
        //        return this.PromotionLevel(fieldType.FieldTypeExpression);
        //    // * Correct Promotion
        //    return 0;
        //}

        #endregion

        // WriteType Unification

        #region Unify
        public override bool Unify(TypeExpression te, SortOfUnification unification, IList<Pair<TypeExpression, TypeExpression>> previouslyUnified) {

            throw new NotImplementedException("NullType.Unify() Not implemented");
        }
        #endregion

        #region IsValueType()

        public override bool IsValueType()
        {
           return false;
        }

        #endregion

        public bool Equals(NullType other)
        {
            return true;
        }

        public override bool Equals(object obj)
        {            
            if (obj.GetType() != typeof (NullType)) 
                return false;
            return Equals((NullType) obj);
        }

        public override int GetHashCode()
        {
            return 0;
        }        
    }
}