atom.h

#pragma once
#include "libnanyc.h"
#include <yuni/core/smartptr/intrusive.h>
#include <yuni/core/string.h>
#include <yuni/core/noncopyable.h>
#include <yuni/core/flags.h>
#include <yuni/core/tribool.h>
#include "details/utils/clid.h"
#include "vardef.h"
#include "nany/nany.h"
#include "details/ir/fwd.h"
#include "signature.h"
#include <unordered_map>
#include <unordered_set>
#include <map>
#include "libnanyc-config.h"
#include "details/atom/classdef.h"



namespace ny {


struct AtomMap;
struct ClassdefTable;
struct ClassdefTableView;
namespace ir { struct Sequence; }


} // namespace ny


namespace ny {


struct Atom final
    : public Yuni::IIntrusiveSmartPtr<Atom, false, Yuni::Policy::SingleThreaded>
    , Yuni::NonCopyable<Atom> {

    enum class Type : yuint8 {
        namespacedef,
        funcdef,
        classdef,
        vardef,
        typealias,
        unit,
    };

    enum class Flags : uint32_t {
        suggestInReport,
        captureVariables,
        error,
        pushCapturedVariables,
        recursive,

        instanciating,
    };

    template<Flags F> struct FlagAutoSwitch final {
        FlagAutoSwitch(Atom& atom) : atom(atom) {
            atom.flags += F;
        }
        ~FlagAutoSwitch() {
            atom.flags -= F;
        }
        Atom& atom;
    };

    enum class Category : uint32_t {
        special,
        funcoperator,
        view,
        classParent,
        ctor,
        clone,
        dtor,
        defvarInit,
        functor,
        capturedVar,
        propget,
        propset,
        propsetCustom,
        unittest,
    };

    struct Parameters final {
        uint size() const;
        bool empty() const;
        bool append(const CLID&, const AnyString& name);
        uint32_t findByName(const AnyString& name, uint32_t offset = 0) const;

        const std::pair<AnyString, Vardef>& operator [] (uint index) const;

        void swap(Parameters&);

        const AnyString& name(uint index) const;
        const Vardef& vardef(uint index) const;

        // \param callbakc void()(uint32_t index, const AnyString& name, const Vardef& vardef)
        template<class T> void each(const T& callback) const;

        // \TODO ishortcircuitvalue: this property is only used twice...
        bool shortcircuitValue = false;

    private:
        struct Data final {
            uint32_t count = 0u;
            std::pair<AnyString, Vardef> params[config::maxFuncDeclParameterCount];
        };
        std::unique_ptr<Data> pData;
    };

public:
    static void extractNames(AnyString& keyword, AnyString& varname, const AnyString& name);

public:
    explicit Atom(const AnyString& name, Type type);
    explicit Atom(Atom& rootparent, const AnyString& name, Type type);
    ~Atom();


    AnyString name() const;
    CLID clid() const;

    bool isNamespace() const;
    bool isClass() const;
    bool isFunction() const;
    bool isOperator() const;
    bool isSpecial() const;
    bool isView() const;
    bool isMemberVariable() const;
    bool isClassMember() const;
    bool isAnonymousClass() const;
    bool isMemberVarDefaultInit() const;
    bool isTypeAlias() const;
    bool isUnit() const;
    bool isCtor() const;
    bool isDtor() const;
    bool isCloneCtor() const;
    bool isFunctor() const;
    bool callable() const;
    bool isCapturedVariable() const;
    bool isProperty() const;
    bool isPropertyGet() const;
    bool isPropertySet() const;
    bool isPropertySetCustom() const;
    bool isUnittest() const;

    bool isPublicOrPublished() const;

    bool hasReturnType() const;

    bool hasGenericParameters() const;

    bool isContextual() const;

    bool canAccessTo(const Atom&) const;

    bool canCaptureVariabes() const;

    Atom* parentScope();

    const Atom* parentScope() const;

    bool nameLookupFromParentScope(std::vector<std::reference_wrapper<Atom>>& list, const AnyString& name);

    bool nameLookupOnChildren(std::vector<std::reference_wrapper<Atom>>& list, const AnyString& name,
        bool* singleHop = nullptr);

    bool propertyLookupOnChildren(std::vector<std::reference_wrapper<Atom>>& list,
        const AnyString& prefix, const AnyString& name);

    bool hasMember(const AnyString& name) const;

    template<class C> void eachChild(const C& callback);
    template<class C> void eachChild(const C& callback) const;

    template<class C> void eachChild(const AnyString& needle, const C& callback);
    template<class C> void eachChild(const AnyString& needle, const C& callback) const;

    uint32_t findClassAtom(Atom*& out, const AnyString& name);
    uint32_t findFuncAtom(Atom*& out, const AnyString& name);
    uint32_t findVarAtom(Atom*& out, const AnyString& name);
    Atom* findNamespaceAtom(const AnyString& name);

    const Atom* findChildByMemberFieldID(uint32_t field) const;

    void renameChild(const AnyString& from, const AnyString& to);

    bool findParent(const Atom& atom) const;

    uint32_t childrenCount() const;

    bool hasChildren() const;



    uint64_t runtimeSizeof() const;


    YString fullname() const;
    void retrieveFullname(YString& out, const ClassdefTableView* table = nullptr,
        bool parentName = true) const;

    // \internal mainly used for convenience and debugging purposes
    YString caption() const;
    // \internal mainly used for convenience and debugging purposes
    YString caption(const ClassdefTableView&) const;
    void retrieveCaption(YString& out, const ClassdefTableView& table) const;

    void printTree(const ClassdefTableView&) const;

    AnyString keyword() const;


public:
    struct Instances final {
        struct Ref final {
            Ref(Instances& ref, uint32_t index): m_ref(ref), m_index(index) {}
            ir::Sequence& ircode();
            ir::Sequence* ircodeIfExists();
            AnyString symbolname() const;
            uint32_t id() const;
            void update(YString&& symbol, const Classdef& rettype);
            uint32_t invalidate(const Signature&);

        private:
            Instances& m_ref;
            uint32_t m_index;
        };

        YString print(const AtomMap&) const;

        Ref create(const Signature& signature, Atom* remapAtom);

        Yuni::Tribool::Value isValid(const Signature& signature, uint32_t& iid, Classdef&, Atom*& remapAtom) const;

        uint32_t size() const;

        Ref operator [] (uint32_t index);

    private:
        void update(uint32_t index, Yuni::String&& symbol, const Classdef& rettype);
        void invalidate(uint32_t index, const Signature&);

        struct Metadata final {
            std::unique_ptr<ir::Sequence> ircode;
            Classdef rettype;
            Atom* remapAtom = nullptr;
            Yuni::String symbol;
        };
        std::vector<Metadata> m_instances;
        std::unordered_map<Signature, uint32_t> m_instancesIDs;
    }
    instances;

    uint32_t atomid = 0u;
    Yuni::Flags<Flags> flags = {Flags::suggestInReport};
    Yuni::Flags<Category> category;

    struct {
        // \note This value is used internally for mapping
        uint16_t fieldindex = 0;
        uint16_t effectiveFieldIndex = 0;
    }
    varinfo;

    struct {
        bool isInstanciated = false;
        // (can be used to retrieve the generic type parameter index when the atom is a typedef)
        uint16_t nextFieldIndex = 0;

        struct {
            uint32_t atomid = 0;
            uint32_t instanceid = (uint32_t) - 1;
        } dtor;

        struct {
            uint32_t atomid = 0;
            uint32_t instanceid = (uint32_t) - 1;
        } clone;
    }
    classinfo;

    const Type type;
    nyvisibility_t visibility = nyv_public;
    Atom* parent = nullptr;

    struct {
        YString filename;
        uint32_t line = 0;
        uint32_t offset = 0;
    }
    origin;

    Vardef returnType;
    Parameters parameters;
    Parameters tmplparams;
    Parameters tmplparamsForPrinting;
    uint32_t localVariablesCount = 0u;
    Atom* scopeForNameResolution = nullptr;

    struct {
        ir::Sequence* ircode = nullptr;
        // \warning offset of the operands of the blueprint, not the opcode value
        uint32_t offset = 0;
        uint32_t stackSizeExtra = 0;
        bool owned = false;
    }
    opcodes;

    // \TODO builtinalias: this property is only used twice
    AnyString builtinalias;
    nytype_t builtinMapping = nyt_void;

    std::unique_ptr<std::unordered_set<AnyString>> candidatesForCapture;

private:
    std::multimap<AnyString, yuni::Ref<Atom>> m_children;
    AnyString m_name;
    // nakama !
    friend struct AtomMap;

}; // class Atom


} // namespace ny

#include "atom.hxx"