PorygonLang/src/ScriptType.hpp

#include <utility>

#include <utility>


#ifndef PORYGONLANG_SCRIPTTYPE_HPP
#define PORYGONLANG_SCRIPTTYPE_HPP

#include <utility>
#include <vector>
#include <memory>
#include "Binder/BoundVariables/BoundVariableKey.hpp"
#include "Utilities/HashedString.hpp"

using namespace std;

namespace Porygon{
    enum class TypeClass{
        Error,
        Nil,
        Number,
        Bool,
        String,
        Function,
        UserData,
        Table,
    };

    class ScriptType{
        TypeClass _class;
    public:
        explicit ScriptType(TypeClass c){
            _class = c;
        }

        virtual ~ScriptType() = default;

        const TypeClass GetClass() const{
            return _class;
        }

        virtual bool operator ==(const ScriptType& b) const{
            return _class == b._class;
        };

        virtual bool operator ==(ScriptType* b) const{
            return _class == b->_class;
        };

        virtual bool operator !=(const ScriptType& b) const{
            return ! (operator==(b));
        }
        virtual bool operator !=(ScriptType* b) const{
            return ! (operator==(b));
        }

        virtual const bool CanBeIndexedWith(ScriptType* indexer) const;
        virtual const bool CanBeIndexedWithIdentifier(uint32_t hash) const{
            return false;
        }

        virtual const shared_ptr<ScriptType> GetIndexedType(ScriptType* indexer) const;
        virtual const shared_ptr<ScriptType> GetIndexedType(uint32_t hash) const{
            throw "This type told the binder it can be indexed, but it does not implement the resulting type.";
        }

        virtual const bool CanBeIterated() const{
            return false;
        }
        virtual shared_ptr<ScriptType> GetIteratorKeyType() const{
            throw "This type told the binder it can be iterated, but it does not implement the resulting type.";
        }
    };

    class NumericScriptType : public ScriptType{
        // Are we aware of whether this is a float or not?
        bool _awareOfFloat;
        // Is this value a float?
        bool _isFloat;
    public:
        explicit NumericScriptType(bool floatAware, bool isFloat) : ScriptType(TypeClass::Number){
            _awareOfFloat = floatAware;
            _isFloat = isFloat;
        }

        const bool IsAwareOfFloat() const{
            return _awareOfFloat;
        }

        const bool IsFloat() const{
            return _isFloat;
        }
    };

    class StringScriptType : public ScriptType{
        bool _isKnownAtBind;
        uint32_t _hashValue;
    public:
        explicit StringScriptType(bool knownAtBind, uint32_t hashValue): ScriptType(TypeClass::String){
            _isKnownAtBind = knownAtBind;
            _hashValue = hashValue;
        }

        const bool IsKnownAtBind() const{
            return _isKnownAtBind;
        }

        const uint32_t GetHashValue() const{
            return _hashValue;
        }
    };

    class GenericFunctionScriptType : public ScriptType{
        shared_ptr<ScriptType> _returnType;
        vector<shared_ptr<ScriptType>> _parameterTypes;
    public:
        GenericFunctionScriptType(std::shared_ptr<ScriptType> returnType, vector<shared_ptr<ScriptType>> parameterTypes)
            : ScriptType(TypeClass::Function){
            _returnType = std::move(returnType);
            _parameterTypes = std::move(parameterTypes);
        }

        const shared_ptr<ScriptType> GetReturnType() const{
            return _returnType;
        }

        void SetReturnType(shared_ptr<ScriptType> t){
            _returnType = std::move(t);
        }

        const vector<shared_ptr<ScriptType>> GetParameterTypes() const{
            return _parameterTypes;
        }

        virtual const bool IsScriptFunction() const = 0;
    };

    class FunctionScriptType : public GenericFunctionScriptType{
        vector<shared_ptr<Binder::BoundVariableKey>> _parameterKeys;
        int _scopeIndex;
    public:
        FunctionScriptType(std::shared_ptr<ScriptType> returnType, vector<shared_ptr<ScriptType>> parameterTypes,
                           vector<shared_ptr<Binder::BoundVariableKey>> parameterKeys, int scopeIndex)
                : GenericFunctionScriptType(std::move(returnType), parameterTypes){
            _parameterKeys = std::move(parameterKeys);
            _scopeIndex = scopeIndex;
        }

        const vector<shared_ptr<Binder::BoundVariableKey>> GetParameterKeys() const{
            return _parameterKeys;
        }

        const int GetScopeIndex() const{
            return _scopeIndex;
        }

        const bool IsScriptFunction() const final{
            return true;
        }
    };

    class NumericalTableScriptType : public ScriptType{
        shared_ptr<ScriptType> _valueType;
        // Consider adding a check whether the table actually contains a type if every key is static.
    public:
        explicit NumericalTableScriptType(shared_ptr<ScriptType> valueType) : ScriptType(TypeClass::Table){
            _valueType = std::move(valueType);
        }

        const bool CanBeIndexedWith(ScriptType* indexer) const final{
            if (indexer -> GetClass() != TypeClass::Number)
                return false;
            auto num =(NumericScriptType*)indexer;
            return !(num->IsAwareOfFloat() && num->IsFloat());
        }

        const shared_ptr<ScriptType> GetIndexedType(ScriptType* indexer) const final{
            return _valueType;
        }

        const bool CanBeIterated() const final{
            return true;
        }
        shared_ptr<ScriptType> GetIteratorKeyType() const final{
            return make_shared<StringScriptType>(false, 0);
        }
    };
}


#endif //PORYGONLANG_SCRIPTTYPE_HPP