feat(macro processor, error): adding better error messages when a macro fails, to show the macro we were expanding and what failed

Author: SuperFola

include/Ark/Compiler/Macros/Executor.hpp

@@ -58,6 +58,14 @@ namespace Ark::internal
          */
         virtual bool canHandle(Node& node) = 0;
 
+        /**
+         * @brief Returns the macro node that will be expanded
+         *
+         * @param node AST node on which the executor will run
+         * @return Node
+         */
+        virtual Node macroNode(Node& node) = 0;
+
     protected:
         unsigned int m_debug;
         MacroProcessor* m_processor;  ///< This is a non-owned pointer.
@@ -118,7 +126,7 @@ namespace Ark::internal
          * @param message the error
          * @param node the node in which there is an error
          */
-        [[noreturn]] static void throwMacroProcessingError(const std::string& message, const Node& node);
+        [[noreturn]] void throwMacroProcessingError(const std::string& message, const Node& node);
     };
 
 }

include/Ark/Compiler/Macros/Executors/Conditional.hpp

@@ -39,6 +39,8 @@ namespace Ark::internal
          * @return true if the executor can handle the given node
          */
         [[nodiscard]] bool canHandle(Node& node) override;
+
+        [[nodiscard]] Node macroNode(Node& node) override;
     };
 
 }

include/Ark/Compiler/Macros/Executors/Function.hpp

@@ -28,7 +28,7 @@ namespace Ark::internal
         /**
          *
          * @param node
-         * @param depth depth of the macro processor evalution
+         * @param depth depth of the macro processor evaluation
          * @return true if the applying worked
          */
         bool applyMacro(Node& node, unsigned depth) override;
@@ -40,6 +40,8 @@ namespace Ark::internal
          */
         [[nodiscard]] bool canHandle(Node& node) override;
 
+        [[nodiscard]] Node macroNode(Node& node) override;
+
     private:
         void unify(const std::unordered_map<std::string, Node>& map, Node& target, Node* parent, std::size_t index = 0, std::size_t unify_depth = 0);
     };

include/Ark/Compiler/Macros/Executors/Symbol.hpp

@@ -28,7 +28,7 @@ namespace Ark::internal
         /**
          *
          * @param node
-         * @param depth depth of the macro processor evalution
+         * @param depth depth of the macro processor evaluation
          * @return true if the applying worked
          */
         bool applyMacro(Node& node, unsigned depth) override;
@@ -39,6 +39,8 @@ namespace Ark::internal
          * @return true if the executor can handle the given node
          */
         [[nodiscard]] bool canHandle(Node& node) override;
+
+        [[nodiscard]] Node macroNode(Node& node) override;
     };
 
 }

include/Ark/Compiler/Macros/Processor.hpp

@@ -55,8 +55,9 @@ namespace Ark::internal
         friend class MacroExecutor;
 
     private:
-        Node m_ast;                        ///< The modified AST
-        std::vector<MacroScope> m_macros;  ///< Handling macros in a scope fashion
+        Node m_ast;                                ///< The modified AST
+        std::vector<MacroScope> m_macros;          ///< Handling macros in a scope fashion
+        std::vector<Node> m_macros_being_applied;  ///< Stack of macros being applied. The last one is the current one we are working on
         std::shared_ptr<MacroExecutor> m_conditional_executor;
         std::vector<std::shared_ptr<MacroExecutor>> m_executors;
         std::unordered_map<std::string, Node> m_defined_functions;
@@ -152,7 +153,7 @@ namespace Ark::internal
          * @param name the name of the macro being applied
          * @param kind the macro kind, empty by default (eg "operator", "condition")
          */
-        static void checkMacroArgCountEq(const Node& node, std::size_t expected, const std::string& name, const std::string& kind = "");
+        void checkMacroArgCountEq(const Node& node, std::size_t expected, const std::string& name, const std::string& kind = "");
 
         /**
          * @brief Check if the given node has at least the provided argument count, otherwise throws an error
@@ -162,7 +163,7 @@ namespace Ark::internal
          * @param name the name of the macro being applied
          * @param kind the macro kind, empty by default (eg "operator", "condition")
          */
-        static void checkMacroArgCountGe(const Node& node, std::size_t expected, const std::string& name, const std::string& kind = "");
+        void checkMacroArgCountGe(const Node& node, std::size_t expected, const std::string& name, const std::string& kind = "");
 
         /**
          * @brief Evaluate only the macros
@@ -181,15 +182,15 @@ namespace Ark::internal
          * @return true
          * @return false
          */
-        static bool isTruthy(const Node& node);
+        bool isTruthy(const Node& node);
 
         /**
          * @brief Throw a macro processing error
          *
          * @param message the error
          * @param node the node in which there is an error
          */
-        [[noreturn]] static void throwMacroProcessingError(const std::string& message, const Node& node);
+        [[noreturn]] void throwMacroProcessingError(const std::string& message, const Node& node) const;
     };
 }
 

include/Ark/Exceptions.hpp

@@ -103,6 +103,7 @@ namespace Ark
         const std::size_t col;
         const std::string expr;
         const std::optional<internal::utf8_char_t> symbol;
+        const bool is_macro_expansion = false;
 
         CodeErrorContext(std::string filename_, const std::size_t lineNum, const std::size_t column, std::string expression, const std::optional<internal::utf8_char_t> maybe_symbol = std::nullopt) :
             filename(std::move(filename_)),
@@ -111,6 +112,15 @@ namespace Ark
             expr(std::move(expression)),
             symbol(maybe_symbol)
         {}
+
+        CodeErrorContext(std::string filename_, const std::size_t lineNum, const std::size_t column, std::string expression, const bool from_macro_expansion) :
+            filename(std::move(filename_)),
+            line(lineNum),
+            col(column),
+            expr(std::move(expression)),
+            symbol(std::nullopt),
+            is_macro_expansion(from_macro_expansion)
+        {}
     };
 
     /**

src/arkreactor/Compiler/Macros/Executor.cpp

@@ -36,6 +36,6 @@ namespace Ark::internal
 
     void MacroExecutor::throwMacroProcessingError(const std::string& message, const Node& node)
     {
-        MacroProcessor::throwMacroProcessingError(message, node);
+        m_processor->throwMacroProcessingError(message, node);
     }
 }

src/arkreactor/Compiler/Macros/Executors/Conditional.cpp

@@ -34,4 +34,9 @@ namespace Ark::internal
     {
         return node.nodeType() == NodeType::Macro && node.list()[0].nodeType() == NodeType::Keyword && node.list()[0].keyword() == Keyword::If;
     }
+
+    Node ConditionalExecutor::macroNode(Node& node)
+    {
+        return node;
+    }
 }

src/arkreactor/Compiler/Macros/Executors/Function.cpp

@@ -87,6 +87,14 @@ namespace Ark::internal
         return false;
     }
 
+    Node FunctionExecutor::macroNode(Node& node)
+    {
+        const Node& first = node.list()[0];
+        if (const Node* macro = findNearestMacro(first.string()); macro != nullptr && macro->constList().size() == 3)
+            return *macro;
+        return {};
+    }
+
     void FunctionExecutor::unify(const std::unordered_map<std::string, Node>& map, Node& target, Node* parent, const std::size_t index, const std::size_t unify_depth)
     {
         if (unify_depth > MaxMacroUnificationDepth)

src/arkreactor/Compiler/Macros/Executors/Symbol.cpp

@@ -23,4 +23,11 @@ namespace Ark::internal
 
         return false;
     }
+
+    Node SymbolExecutor::macroNode(Node& node)
+    {
+        if (const Node* macro = findNearestMacro(node.string()); macro != nullptr)
+            return *macro;
+        return {};
+    }
 }