feat: new class for runtime type checking

Author: nos1dot618

CMakeLists.txt

@@ -19,6 +19,7 @@ add_library(frontend STATIC
 
 add_library(runtime STATIC
     ${CMAKE_SOURCE_DIR}/src/runtime/interpreter.cpp
+    ${CMAKE_SOURCE_DIR}/src/runtime/type.cpp
     ${CMAKE_SOURCE_DIR}/src/runtime/builtins.cpp
     ${CMAKE_SOURCE_DIR}/src/runtime/builtin-modules/builtin_module_core.cpp
     ${CMAKE_SOURCE_DIR}/src/runtime/builtin-modules/builtin_module_list.cpp

include/lbd/runtime/interpreter.h

@@ -64,6 +64,7 @@ namespace runtime {
 
         int arity;
         std::string name;
+        // TODO: We can store signature of native-function here.
         Implementation implementation;
 
         [[nodiscard]] std::string toString() const;

include/lbd/runtime/type.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <lbd/runtime/interpreter.h>
+
+/// These are runtime-types different from frontend::type.
+
+namespace runtime::type {
+    enum class TypeTag {
+        Float,
+        String,
+        Closure,
+        NativeFunction,
+        List,
+        Any
+    };
+
+    TypeTag typeTagFromValue(const Value &value);
+
+    std::string typeTagToString(TypeTag tag);
+
+    struct Type {
+        virtual ~Type() = default;
+
+        [[nodiscard]] virtual bool matches(const Value &value) const = 0;
+
+        [[nodiscard]] virtual std::string toString() const = 0;
+
+        [[nodiscard]] virtual bool isCallable() const;
+    };
+
+    struct SimpleType final : Type {
+        explicit SimpleType(TypeTag tag);
+
+        [[nodiscard]] bool matches(const Value &value) const override;
+
+        [[nodiscard]] std::string toString() const override;
+
+        [[nodiscard]] bool isCallable() const override;
+
+    private:
+        TypeTag tag;
+    };
+
+    struct ListType final : Type {
+        explicit ListType(const std::shared_ptr<Type> &elementType);
+
+        [[nodiscard]] bool matches(const Value &value) const override;
+
+        [[nodiscard]] std::string toString() const override;
+
+        [[nodiscard]] bool isCallable() const override;
+
+    private:
+        std::shared_ptr<Type> elementType;
+    };
+
+    struct FunctionType final : Type {
+        // TODO: Add support for variadic, maybe by adding a default parameter 'isVariadic'.
+        explicit FunctionType(const std::vector<std::shared_ptr<Type> > &argumentTypes,
+                              const std::shared_ptr<Type> &returnType);
+
+        [[nodiscard]] bool matches(const Value &value) const override;
+
+        [[nodiscard]] std::string toString() const override;
+
+        [[nodiscard]] bool isCallable() const override;
+
+        [[nodiscard]] int arity() const;
+
+    private:
+        std::vector<std::shared_ptr<Type> > argumentTypes;
+        std::shared_ptr<Type> returnType;
+    };
+}

src/runtime/type.cpp

@@ -0,0 +1,117 @@
+#include <lbd/runtime/type.h>
+#include <lbd/error.h>
+
+namespace runtime::type {
+    inline TypeTag typeTagFromValue(const Value &value) {
+        return std::visit([&]<typename T0>(T0 &&_) -> TypeTag {
+            using T = std::decay_t<T0>;
+            if constexpr (std::is_same_v<T, double>) {
+                return TypeTag::Float;
+            } else if constexpr (std::is_same_v<T, std::string>) {
+                return TypeTag::String;
+            } else if constexpr (std::is_same_v<T, Closure>) {
+                return TypeTag::Closure;
+            } else if constexpr (std::is_same_v<T, std::shared_ptr<NativeFunction> >) {
+                return TypeTag::NativeFunction;
+            } else if constexpr (std::is_same_v<T, std::shared_ptr<List> >) {
+                return TypeTag::List;
+            } else {
+                return TypeTag::Any;
+            }
+        }, value);
+    }
+
+    inline std::string typeTagToString(const TypeTag tag) {
+        switch (tag) {
+            case TypeTag::Float:
+                return "Float";
+            case TypeTag::String:
+                return "String";
+            case TypeTag::Closure:
+                return "Closure";
+            case TypeTag::NativeFunction:
+                return "NativeFunction";
+            case TypeTag::List:
+                return "List";
+            case TypeTag::Any:
+                return "Any";
+            default:
+                STATIC_ASSERT(true, "unhandled type");
+                return "UNKNOWN_TYPE"; // Unreachable
+        }
+    }
+
+    SimpleType::SimpleType(const TypeTag tag) : tag(tag) {
+    }
+
+    bool SimpleType::matches(const Value &value) const {
+        return tag == TypeTag::Any || tag == typeTagFromValue(value);
+    }
+
+    std::string SimpleType::toString() const {
+        return typeTagToString(tag);
+    }
+
+    bool SimpleType::isCallable() const {
+        return false;
+    }
+
+    ListType::ListType(const std::shared_ptr<Type> &elementType) : elementType(elementType) {
+    }
+
+    bool ListType::matches(const Value &value) const {
+        if (typeTagFromValue(value) != TypeTag::Any) {
+            return false;
+        }
+        auto &[elements] = *std::get<std::shared_ptr<List> >(value);
+        return std::all_of(elements.begin(), elements.end(), [&](const auto &element) {
+            return elementType->matches(element);
+        });
+    }
+
+    std::string ListType::toString() const {
+        std::ostringstream outputStringStream;
+        outputStringStream << "[" << elementType->toString() << "]";
+        return outputStringStream.str();
+    }
+
+    bool ListType::isCallable() const {
+        return false;
+    }
+
+    FunctionType::FunctionType(const std::vector<std::shared_ptr<Type> > &argumentTypes,
+                               const std::shared_ptr<Type> &returnType) : argumentTypes(argumentTypes),
+                                                                          returnType(returnType) {
+    }
+
+    bool FunctionType::matches(const Value &value) const {
+        // TODO: Complete this.
+        return false;
+    }
+
+    std::string FunctionType::toString() const {
+        std::ostringstream outputStringStream;
+        for (auto &argumentType: argumentTypes) {
+            if (argumentType->isCallable()) {
+                outputStringStream << "(" << argumentType->toString() << ") ";
+            } else {
+                outputStringStream << argumentType->toString() << " ";
+            }
+        }
+        if (returnType->isCallable()) {
+            outputStringStream << "(" << returnType->toString() << ") ";
+        } else {
+            outputStringStream << returnType->toString() << " ";
+        }
+        return outputStringStream.str();
+    }
+
+    bool FunctionType::isCallable() const {
+        return true;
+    }
+
+    int FunctionType::arity() const {
+        // TODO: For variadic-functions return '-1'.
+        return argumentTypes.size();
+    }
+}