Implementing the new imports syntax

.pre-commit-config.yaml

@@ -22,7 +22,8 @@ repos:
           "--inline-suppr",
           "--suppressions-list=cppcheck-suppressions.txt",
           "--suppress=unusedStructMember",
-          "--suppress=checkersReport"
+          "--suppress=checkersReport",
+          "--check-level=exhaustive"
         ]
   - repo: https://github.com/compilerla/conventional-pre-commit
     rev: 'v3.2.0'

CHANGELOG.md

@@ -30,6 +30,7 @@
 - new `MAKE_CLOSURE <page addr>` instruction, generated in place of a `LOAD_CONST` when a closure is made
 - added `-fdump-ir` to dump the IR entities to a file named `{file}.ark.ir`
 - added 11 super instructions and their implementation to the VM
+- support for the glob import syntax and symbol import syntax
 
 ### Changed
 - instructions are on 4 bytes: 1 byte for the instruction, 1 byte of padding, 2 bytes for an immediate argument
@@ -90,6 +91,7 @@
 - the parser can detect ill-formed macros (that are seen as function macros while being value macros)
 - adding a `CALL_BUILTIN <builtin> <arg count>` super instruction
 - fixed formatting of comments after the last symbol in an import node
+- renamed `str:xyz` builtins to `string:xyz` for uniformity with the standard library
 
 ### Removed
 - removed unused `NodeType::Closure`

examples/99bottles.ark

@@ -20,6 +20,6 @@
 
 (mut n i)
 (while (> n 1) {
-  (print (str:format "{} Bottles of beer on the wall\n{} bottles of beer\nTake one down, pass it around" n n))
+  (print (string:format "{} Bottles of beer on the wall\n{} bottles of beer\nTake one down, pass it around" n n))
   (set n (- n 1))
-  (print (str:format "{} Bottles of beer on the wall." n)) })
+  (print (string:format "{} Bottles of beer on the wall." n)) })

examples/blockchain.ark

@@ -104,9 +104,9 @@
     (let new (json:fromString request))
     (set nodes_transactions (append nodes_transactions new))
     (print "New transaction")
-    (print (str:format "FROM:   {}" (json:get new "from")))
-    (print (str:format "TO:     {}" (json:get new "to")))
-    (print (str:format "AMOUNT: {}" (json:get new "amount")))
+    (print (string:format "FROM:   {}" (json:get new "from")))
+    (print (string:format "TO:     {}" (json:get new "to")))
+    (print (string:format "AMOUNT: {}" (json:get new "amount")))
 
     # return value
     [200 "transaction submission successful" "text/plain"] }))

examples/sum_digits.ark

@@ -2,7 +2,7 @@
 (import std.String)
 
 (let to-base (fun (n base) {
-  (let o (str:ord n))
+  (let o (string:ord n))
 
   (let v
     (if (and (>= o 48) (<= o 57))

include/Ark/Builtins/Builtins.hpp

@@ -72,11 +72,11 @@ namespace Ark::internal::Builtins
 
     namespace String
     {
-        Value format(std::vector<Value>& n, VM* vm);       // str:format, multiple arguments
-        Value findSubStr(std::vector<Value>& n, VM* vm);   // str:find, 2 arguments
-        Value removeAtStr(std::vector<Value>& n, VM* vm);  // str:removeAt, 2 arguments
-        Value ord(std::vector<Value>& n, VM* vm);          // str:ord, 1 arguments
-        Value chr(std::vector<Value>& n, VM* vm);          // str:chr, 1 arguments
+        Value format(std::vector<Value>& n, VM* vm);       // string:format, multiple arguments
+        Value findSubStr(std::vector<Value>& n, VM* vm);   // string:find, 2 arguments
+        Value removeAtStr(std::vector<Value>& n, VM* vm);  // string:removeAt, 2 arguments
+        Value ord(std::vector<Value>& n, VM* vm);          // string:ord, 1 arguments
+        Value chr(std::vector<Value>& n, VM* vm);          // string:chr, 1 arguments
     }
 
     namespace Mathematics

include/Ark/Compiler/AST/Import.hpp

@@ -1,5 +1,5 @@
-#ifndef COMPILER_AST_IMPORT_HPP
-#define COMPILER_AST_IMPORT_HPP
+#ifndef ARK_COMPILER_AST_IMPORT_HPP
+#define ARK_COMPILER_AST_IMPORT_HPP
 
 #include <vector>
 #include <string>
@@ -31,13 +31,18 @@ namespace Ark::internal
         std::vector<std::string> package;
 
         /**
-         * @brief Import with prefix (the package) or not
+         * @brief Import with prefix (import package)
          *
          */
         bool with_prefix = true;
 
         /**
-         * @brief List of symbols to import, can be empty if none provided
+         * @brief Import as glob (import package:*)
+         */
+        bool is_glob = false;
+
+        /**
+         * @brief List of symbols to import, can be empty if none provided. (import package :a :b)
          *
          */
         std::vector<std::string> symbols;
@@ -68,17 +73,6 @@ namespace Ark::internal
                 });
         }
 
-        /**
-         * @brief Check if we should import everything, given something like `(import foo.bar.egg:*)`
-         *
-         * @return true if all symbols of the file should be imported in the importer scope
-         * @return false otherwise
-         */
-        [[nodiscard]] bool isGlob() const
-        {
-            return !with_prefix && symbols.empty();
-        }
-
         /**
          * @brief Check if we should import everything with a prefix, given a `(import foo.bar.egg)`
          *

include/Ark/Compiler/AST/Namespace.hpp

@@ -0,0 +1,33 @@
+#ifndef ARK_COMPILER_AST_NAMESPACE_HPP
+#define ARK_COMPILER_AST_NAMESPACE_HPP
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Ark::internal
+{
+    class Node;
+
+    struct Namespace
+    {
+        std::string name;
+        bool is_glob;                      // (import package:*)
+        bool with_prefix;                  // (import package)
+        std::vector<std::string> symbols;  // (import package :a :b)
+        std::shared_ptr<Node> ast;
+    };
+
+    inline bool operator==(const Namespace& A, const Namespace& B)
+    {
+        return A.name == B.name && A.is_glob == B.is_glob &&
+            A.with_prefix == B.with_prefix;
+    }
+
+    inline bool operator<([[maybe_unused]] const Namespace&, [[maybe_unused]] const Namespace&)
+    {
+        return true;
+    }
+}
+
+#endif  // ARK_COMPILER_AST_NAMESPACE_HPP

include/Ark/Compiler/AST/Node.hpp

@@ -17,6 +17,7 @@
 #include <string>
 #include <vector>
 
+#include <Ark/Compiler/AST/Namespace.hpp>
 #include <Ark/Compiler/Common.hpp>
 #include <Ark/Platform.hpp>
 
@@ -29,7 +30,7 @@ namespace Ark::internal
     class ARK_API Node
     {
     public:
-        using Value = std::variant<double, std::string, Keyword, std::vector<Node>>;
+        using Value = std::variant<double, std::string, Keyword, std::vector<Node>, Namespace>;
 
         Node() = default;
 
@@ -39,6 +40,7 @@ namespace Ark::internal
         explicit Node(double value);
         explicit Node(long value);
         explicit Node(Keyword value);
+        explicit Node(Namespace namespace_);
 
         /**
          * @brief Return the string held by the value (if the node type allows it)
@@ -61,6 +63,20 @@ namespace Ark::internal
          */
         [[nodiscard]] Keyword keyword() const noexcept;
 
+        /**
+         * @brief Return the namespace held by the value (if the node type allows it)
+         *
+         * @return Namespace&
+         */
+        [[nodiscard]] Namespace& arkNamespace() noexcept;
+
+        /**
+         * @brief Return the namespace held by the value (if the node type allows it)
+         *
+         * @return const Namespace&
+         */
+        [[nodiscard]] const Namespace& constArkNamespace() const noexcept;
+
         /**
          * @brief Every node has a list as well as a value so we can push_back on all node no matter their type
          *
@@ -96,6 +112,13 @@ namespace Ark::internal
          */
         [[nodiscard]] bool isListLike() const noexcept;
 
+        /**
+         * @brief Check if the node is a string like node
+         * @return true if the node is either a symbol, a string or a spread
+         * @return false
+         */
+        [[nodiscard]] bool isStringLike() const noexcept;
+
         /**
          * @brief Copy a node to the current one, while keeping the filename and position in the file
          *

include/Ark/Compiler/Common.hpp

@@ -2,7 +2,7 @@
  * @file Common.hpp
  * @author Alexandre Plateau (lexplt.dev@gmail.com)
  * @brief Common code for the compiler
- * @version 0.4
+ * @version 0.5
  * @date 2021-10-02
  *
  * @copyright Copyright (c) 2021-2024
@@ -36,11 +36,12 @@ namespace Ark::internal
         Spread,
         Field,
         Macro,
+        Namespace,
         Unused
     };
 
     /// Node types as string, in the same order as the enum NodeType
-    constexpr std::array<std::string_view, 10> nodeTypes = {
+    constexpr std::array<std::string_view, 11> nodeTypes = {
         "Symbol",
         "Capture",
         "Keyword",
@@ -50,6 +51,7 @@ namespace Ark::internal
         "Spread",
         "Field",
         "Macro",
+        "Namespace",
         "Unused"
     };
 

include/Ark/Compiler/Macros/Processor.hpp

@@ -130,8 +130,9 @@ namespace Ark::internal
          *
          * @param node node on which to operate
          * @param depth
+         * @param is_processing_namespace
          */
-        void processNode(Node& node, unsigned depth);
+        void processNode(Node& node, unsigned depth, bool is_processing_namespace = false);
 
         /**
          * @brief Apply a macro on a given node