Reformat front-end library.

Author: nos1dot618

CMakeLists.txt

@@ -1,16 +1,27 @@
 cmake_minimum_required(VERSION 3.20)
 project(lambda-discipline)
 
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
+###### SOURCE ######
+file(GLOB_RECURSE SOURCE_SOURCE_FILES CONFIGURE_DEPENDS
+    ${PROJECT_SOURCE_DIR}/src/source/*.cpp
+)
+add_library(lbdSource STATIC)
+target_sources(lbdSource PRIVATE ${SOURCE_SOURCE_FILES})
+target_include_directories(lbdSource PUBLIC ${PROJECT_SOURCE_DIR}/include)
+
 ####### FRONTEND #######
 file(GLOB_RECURSE FRONTEND_SOURCE_FILES CONFIGURE_DEPENDS
     ${PROJECT_SOURCE_DIR}/src/frontend/*.cpp
 )
 add_library(lbdFrontend STATIC)
 target_sources(lbdFrontend PRIVATE ${FRONTEND_SOURCE_FILES})
+target_link_libraries(lbdFrontend PUBLIC
+    lbdSource
+)
 target_include_directories(lbdFrontend PUBLIC
     ${PROJECT_SOURCE_DIR}/include
 )
@@ -21,6 +32,9 @@ file(GLOB_RECURSE RUNTIME_SOURCE_FILES CONFIGURE_DEPENDS
 )
 add_library(lbdRuntime STATIC)
 target_sources(lbdRuntime PRIVATE ${RUNTIME_SOURCE_FILES})
+target_link_libraries(lbdRuntime PUBLIC
+    lbdSource
+)
 target_include_directories(lbdRuntime PUBLIC
     ${PROJECT_SOURCE_DIR}/include
 )

include/lbd/Context.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <lbd/Options.hpp>
+#include <lbd/source/SourceManager.hpp>
+
+namespace lbd
+{
+    class Context
+    {
+    public:
+        explicit Context(Options options);
+
+        [[nodiscard]] source::SourceManager& getSourceManager();
+
+        [[nodiscard]] Options& getOptions();
+
+        // TODO: Add diagnostic emitter and renderer.
+
+    private:
+        Options options;
+        source::SourceManager sourceManager;
+    };
+}

include/lbd/Options.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <lbd/logs.h>
+
+namespace lbd
+{
+    class Options
+    {
+    public:
+        explicit Options(bool ownExpression = false, bool forceOnEnvironmentDump = false, bool debug = false);
+
+        [[nodiscard]] bool shouldOwnExpression() const;
+
+        [[nodiscard]] bool shouldForceOnEnvironmentDump() const;
+
+        [[nodiscard]] bool isDebug() const;
+
+        void toggleForceOnEnvironmentDump();
+
+        void toggleDebug();
+
+        // TODO: Instead use diagnostic emitter and renderer.
+        Logger logger;
+
+    private:
+        bool ownExpression; /// Owning Expression inside Thunk. Turned on for REPL
+        bool forceOnEnvironmentDump;
+        bool debug;
+    };
+}

include/lbd/cmd.h

@@ -4,16 +4,18 @@
 #include <optional>
 #include <string>
 
-namespace cmd {
-    struct Options {
+namespace cmd
+{
+    struct Options
+    {
         std::optional<std::string> filepath;
         bool showHelp = false;
         bool repl = false;
         bool debug = false;
         bool generateDocs = false;
     };
 
-    void printHelp(std::ostream &outputStream, const std::string &programName);
+    void printHelp(std::ostream& outputStream, const std::string& programName);
 
-    Options parseArguments(int argc, char **argv, const std::string &programName);
+    Options parseArguments(int argc, char** argv, const std::string& programName);
 }

include/lbd/docs.h

@@ -2,6 +2,7 @@
 
 #include <iostream>
 
-namespace docs {
-    void dumpDocs(std::ostream &outputStream);
+namespace lbd::docs
+{
+    void dumpDocs(std::ostream& outputStream);
 }

include/lbd/error.h

@@ -2,7 +2,7 @@
 
 #include <cassert>
 
-template<typename>
+template <typename>
 inline constexpr bool alwaysFalseValue = false;
 
 #define STATIC_ASSERT(VAL, MSG) \

include/lbd/exceptions.h

@@ -2,8 +2,10 @@
 
 #include <exception>
 
-struct ControlledExit final : std::exception {
-    const char *what() const noexcept override {
+struct ControlledExit final : std::exception
+{
+    [[nodiscard]] const char* what() const noexcept override
+    {
         return "Controlled non-fatal exit";
     }
 };

include/lbd/frontend/ast.h

@@ -0,0 +1,122 @@
+#pragma once
+
+#include <string>
+#include <variant>
+#include <vector>
+#include <lbd/frontend/type.h>
+#include <lbd/source/Location.hpp>
+
+namespace lbd::frontend::ast
+{
+    struct IdentifierAstNode
+    {
+        // TODO: This can be a std::string_view.
+        std::string value;
+        source::Location location;
+
+        friend std::ostream& operator<<(std::ostream& outputStream, const IdentifierAstNode& node);
+    };
+
+    struct StringAstNode
+    {
+        std::string value;
+        source::Location location;
+
+        friend std::ostream& operator<<(std::ostream& outputStream, const StringAstNode& node);
+    };
+
+    // TODO: Rename this to NumberAstNode.
+    struct FloatAstNode
+    {
+        double value;
+        source::Location location;
+
+        friend std::ostream& operator<<(std::ostream& outputStream, const FloatAstNode& node);
+    };
+
+    struct Expression;
+
+    struct LambdaExpression
+    {
+        IdentifierAstNode argument;
+        interpreter::type::Type argumentType;
+        std::unique_ptr<Expression> expression;
+        source::Location location;
+
+        void print(std::ostream& outputStream, size_t indent) const;
+
+        friend std::ostream& operator<<(std::ostream& outputStream, const LambdaExpression& lambdaExpression);
+    };
+
+    struct FunctionApplication
+    {
+        IdentifierAstNode functionName;
+        std::vector<std::unique_ptr<Expression>> arguments;
+        source::Location location;
+
+        void print(std::ostream& outputStream, size_t indent) const;
+
+        friend std::ostream& operator<<(std::ostream& outputStream, const FunctionApplication& functionApplication);
+    };
+
+    struct Expression
+    {
+        using ExpressionVariant = std::variant<
+            IdentifierAstNode,
+            StringAstNode,
+            FloatAstNode,
+            LambdaExpression,
+            FunctionApplication
+        >;
+
+        ExpressionVariant value;
+
+        explicit Expression(IdentifierAstNode value);
+
+        explicit Expression(StringAstNode value);
+
+        explicit Expression(FloatAstNode value);
+
+        explicit Expression(LambdaExpression value);
+
+        explicit Expression(FunctionApplication value);
+
+        void print(std::ostream& outputStream, size_t indent) const;
+
+        friend std::ostream& operator<<(std::ostream& outputStream, const Expression& expression);
+
+        [[nodiscard]] source::Location getLocation() const;
+
+        Expression(const Expression&) = delete;
+
+        Expression& operator=(const Expression&) = delete;
+
+        Expression(Expression&&) noexcept = default;
+
+        Expression& operator=(Expression&&) noexcept = default;
+    };
+
+    struct DefinitionAstNode
+    {
+        IdentifierAstNode definitionName;
+        interpreter::type::Type definitionType;
+        Expression expression;
+        source::Location location;
+
+        void print(std::ostream& outputStream, size_t indent) const;
+
+        friend std::ostream& operator<<(std::ostream& outputStream, const DefinitionAstNode& node);
+    };
+
+    // NOTE: Owning and move-only, not copyable.
+    struct AstNode
+    {
+        using NodeVariant = std::variant<Expression, DefinitionAstNode>;
+
+        NodeVariant value;
+
+        void print(std::ostream& outputStream, size_t indent) const;
+
+        friend std::ostream& operator<<(std::ostream& outputStream, const AstNode& node);
+    };
+}