diff --git a/src/language/ast/ASTModulesImporter.cpp b/src/language/ast/ASTModulesImporter.cpp
index d52b964a8a670ca3af3d0bcd0f3223798e2502c3..fa3f479e307fd2b0c78d265879c22157dfec85b8 100644
--- a/src/language/ast/ASTModulesImporter.cpp
+++ b/src/language/ast/ASTModulesImporter.cpp
@@ -1,6 +1,7 @@
 #include <language/ast/ASTModulesImporter.hpp>
 
 #include <language/PEGGrammar.hpp>
+#include <language/utils/OperatorRepository.hpp>
 
 void
 ASTModulesImporter::_importModule(ASTNode& import_node)
@@ -20,6 +21,7 @@ ASTModulesImporter::_importModule(ASTNode& import_node)
   std::cout << " * importing '" << rang::fgB::green << module_name << rang::style::reset << "' module\n";
 
   m_module_repository.populateSymbolTable(module_name_node, m_symbol_table);
+  m_module_repository.registerOperators(module_name);
 }
 
 void
@@ -37,6 +39,7 @@ ASTModulesImporter::_importAllModules(ASTNode& node)
 ASTModulesImporter::ASTModulesImporter(ASTNode& root_node) : m_symbol_table{*root_node.m_symbol_table}
 {
   Assert(root_node.is_root());
+  OperatorRepository::instance().reset();
   m_module_repository.populateMandatorySymbolTable(root_node, m_symbol_table);
 
   this->_importAllModules(root_node);
diff --git a/src/language/modules/CoreModule.cpp b/src/language/modules/CoreModule.cpp
index 14a9548238c91682aac53850a6cdf6f36b4d9e93..0c4f2b354adb6a059fb92cff28e196178a08effb 100644
--- a/src/language/modules/CoreModule.cpp
+++ b/src/language/modules/CoreModule.cpp
@@ -1,5 +1,33 @@
 #include <language/modules/CoreModule.hpp>
 
+#include <language/utils/AffectationProcessorBuilder.hpp>
+#include <language/utils/AffectationRegisterForB.hpp>
+#include <language/utils/AffectationRegisterForN.hpp>
+#include <language/utils/AffectationRegisterForR.hpp>
+#include <language/utils/AffectationRegisterForRn.hpp>
+#include <language/utils/AffectationRegisterForRnxn.hpp>
+#include <language/utils/AffectationRegisterForString.hpp>
+#include <language/utils/AffectationRegisterForZ.hpp>
+
+#include <language/utils/BinaryOperatorRegisterForB.hpp>
+#include <language/utils/BinaryOperatorRegisterForN.hpp>
+#include <language/utils/BinaryOperatorRegisterForR.hpp>
+#include <language/utils/BinaryOperatorRegisterForRn.hpp>
+#include <language/utils/BinaryOperatorRegisterForRnxn.hpp>
+#include <language/utils/BinaryOperatorRegisterForString.hpp>
+#include <language/utils/BinaryOperatorRegisterForZ.hpp>
+
+#include <language/utils/IncDecOperatorRegisterForN.hpp>
+#include <language/utils/IncDecOperatorRegisterForR.hpp>
+#include <language/utils/IncDecOperatorRegisterForZ.hpp>
+
+#include <language/utils/UnaryOperatorRegisterForB.hpp>
+#include <language/utils/UnaryOperatorRegisterForN.hpp>
+#include <language/utils/UnaryOperatorRegisterForR.hpp>
+#include <language/utils/UnaryOperatorRegisterForRn.hpp>
+#include <language/utils/UnaryOperatorRegisterForRnxn.hpp>
+#include <language/utils/UnaryOperatorRegisterForZ.hpp>
+
 #include <language/modules/CoreModule.hpp>
 #include <language/modules/ModuleRepository.hpp>
 #include <language/utils/ASTExecutionInfo.hpp>
@@ -42,3 +70,46 @@ CoreModule::CoreModule() : BuiltinModule(true)
 
                                                ));
 }
+
+void
+CoreModule::registerOperators() const
+{
+  AffectationRegisterForB{};
+  AffectationRegisterForN{};
+  AffectationRegisterForZ{};
+  AffectationRegisterForR{};
+  AffectationRegisterForRn<1>{};
+  AffectationRegisterForRn<2>{};
+  AffectationRegisterForRn<3>{};
+  AffectationRegisterForRnxn<1>{};
+  AffectationRegisterForRnxn<2>{};
+  AffectationRegisterForRnxn<3>{};
+  AffectationRegisterForString{};
+
+  BinaryOperatorRegisterForB{};
+  BinaryOperatorRegisterForN{};
+  BinaryOperatorRegisterForZ{};
+  BinaryOperatorRegisterForR{};
+  BinaryOperatorRegisterForRn<1>{};
+  BinaryOperatorRegisterForRn<2>{};
+  BinaryOperatorRegisterForRn<3>{};
+  BinaryOperatorRegisterForRnxn<1>{};
+  BinaryOperatorRegisterForRnxn<2>{};
+  BinaryOperatorRegisterForRnxn<3>{};
+  BinaryOperatorRegisterForString{};
+
+  IncDecOperatorRegisterForN{};
+  IncDecOperatorRegisterForR{};
+  IncDecOperatorRegisterForZ{};
+
+  UnaryOperatorRegisterForB{};
+  UnaryOperatorRegisterForN{};
+  UnaryOperatorRegisterForZ{};
+  UnaryOperatorRegisterForR{};
+  UnaryOperatorRegisterForRn<1>{};
+  UnaryOperatorRegisterForRn<2>{};
+  UnaryOperatorRegisterForRn<3>{};
+  UnaryOperatorRegisterForRnxn<1>{};
+  UnaryOperatorRegisterForRnxn<2>{};
+  UnaryOperatorRegisterForRnxn<3>{};
+}
diff --git a/src/language/modules/CoreModule.hpp b/src/language/modules/CoreModule.hpp
index 963719be2bce1b841fe9cee05db5b957ad53ba2b..88c673d65a7d9635aba8698c678dda7bd2081fb1 100644
--- a/src/language/modules/CoreModule.hpp
+++ b/src/language/modules/CoreModule.hpp
@@ -12,6 +12,8 @@ class CoreModule : public BuiltinModule
     return "core";
   }
 
+  void registerOperators() const final;
+
   CoreModule();
   ~CoreModule() = default;
 };
diff --git a/src/language/modules/IModule.hpp b/src/language/modules/IModule.hpp
index 48e4b15360de922a83025921d1058095cc205d89..ceb3fd3dffc7d0af7f6423e3a21e7e8aa9686ffc 100644
--- a/src/language/modules/IModule.hpp
+++ b/src/language/modules/IModule.hpp
@@ -25,6 +25,8 @@ class IModule
 
   virtual const NameTypeMap& getNameTypeMap() const = 0;
 
+  virtual void registerOperators() const = 0;
+
   virtual std::string_view name() const = 0;
 
   virtual ~IModule() = default;
diff --git a/src/language/modules/LinearSolverModule.cpp b/src/language/modules/LinearSolverModule.cpp
index a5bb2cf90058b9232bd84e2f2bbdd71eb02ef3c7..5dafbadcfedec464b83d7d20ce798e81518e073d 100644
--- a/src/language/modules/LinearSolverModule.cpp
+++ b/src/language/modules/LinearSolverModule.cpp
@@ -90,3 +90,7 @@ LinearSolverModule::LinearSolverModule()
 
                                                 ));
 }
+
+void
+LinearSolverModule::registerOperators() const
+{}
diff --git a/src/language/modules/LinearSolverModule.hpp b/src/language/modules/LinearSolverModule.hpp
index 5dc7ae64efd3ed43f554e821693f761b0a66d412..7e30c6b2f7c12cf4ede853578e6c064c7dce6292 100644
--- a/src/language/modules/LinearSolverModule.hpp
+++ b/src/language/modules/LinearSolverModule.hpp
@@ -12,6 +12,8 @@ class LinearSolverModule : public BuiltinModule
     return "linear_solver";
   }
 
+  void registerOperators() const final;
+
   LinearSolverModule();
   ~LinearSolverModule() = default;
 };
diff --git a/src/language/modules/MathModule.cpp b/src/language/modules/MathModule.cpp
index e774284b385e7e74b8cb715f73b5ebec6f81b02e..aa961e4a0ae250581fad42b644f7d670ef4fdb32 100644
--- a/src/language/modules/MathModule.cpp
+++ b/src/language/modules/MathModule.cpp
@@ -70,3 +70,7 @@ MathModule::MathModule()
   this->_addBuiltinFunction("round", std::make_shared<BuiltinFunctionEmbedder<int64_t(double)>>(
                                        [](double x) -> int64_t { return std::lround(x); }));
 }
+
+void
+MathModule::registerOperators() const
+{}
diff --git a/src/language/modules/MathModule.hpp b/src/language/modules/MathModule.hpp
index 1f001e1938691c4227722adda9724c9d88f33137..c80a74d2da37807750f25a286b9ccd9d12928850 100644
--- a/src/language/modules/MathModule.hpp
+++ b/src/language/modules/MathModule.hpp
@@ -12,6 +12,8 @@ class MathModule : public BuiltinModule
     return "math";
   }
 
+  void registerOperators() const final;
+
   MathModule();
 
   ~MathModule() = default;
diff --git a/src/language/modules/MeshModule.cpp b/src/language/modules/MeshModule.cpp
index 89e678c3fb4095350842b19a9145502cd7f558a8..86c9a0c106e9fe6eece190c93365fc42a47bf864 100644
--- a/src/language/modules/MeshModule.cpp
+++ b/src/language/modules/MeshModule.cpp
@@ -212,3 +212,7 @@ MeshModule::MeshModule()
 
                               ));
 }
+
+void
+MeshModule::registerOperators() const
+{}
diff --git a/src/language/modules/MeshModule.hpp b/src/language/modules/MeshModule.hpp
index ebb1383107ffd288001a48a5abced722ef37a4bd..3ef6f2856d052e7b7c5ab63393843145eec6f230 100644
--- a/src/language/modules/MeshModule.hpp
+++ b/src/language/modules/MeshModule.hpp
@@ -20,6 +20,8 @@ class MeshModule : public BuiltinModule
     return "mesh";
   }
 
+  void registerOperators() const final;
+
   MeshModule();
 
   ~MeshModule() = default;
diff --git a/src/language/modules/ModuleRepository.cpp b/src/language/modules/ModuleRepository.cpp
index 44a437d04dc177cbfc6274420999c94fafaa22c9..d0cd8260ba6d6a3de9d335833d42002519568592 100644
--- a/src/language/modules/ModuleRepository.cpp
+++ b/src/language/modules/ModuleRepository.cpp
@@ -71,6 +71,14 @@ ModuleRepository::populateSymbolTable(const ASTNode& module_name_node, SymbolTab
   if (i_module != m_module_set.end()) {
     const IModule& populating_module = *i_module->second;
 
+    if (populating_module.isMandatory()) {
+      std::ostringstream error_message;
+      error_message << "module '" << rang::fgB::blue << module_name << rang::style::reset << rang::style::bold
+                    << "' is an autoload " << rang::fgB::yellow << "mandatory" << rang::style::reset
+                    << rang::style::bold << " module. It cannot be imported explicitly!";
+      throw ParseError(error_message.str(), module_name_node.begin());
+    }
+
     this->_populateEmbedderTableT(module_name_node, module_name, populating_module.getNameBuiltinFunctionMap(),
                                   ASTNodeDataType::build<ASTNodeDataType::builtin_function_t>(), symbol_table,
                                   symbol_table.builtinFunctionEmbedderTable());
@@ -100,6 +108,8 @@ ModuleRepository::populateMandatorySymbolTable(const ASTNode& root_node, SymbolT
       this->_populateEmbedderTableT(root_node, module_name, i_module->getNameTypeMap(),
                                     ASTNodeDataType::build<ASTNodeDataType::type_name_id_t>(), symbol_table,
                                     symbol_table.typeEmbedderTable());
+
+      i_module->registerOperators();
     }
   }
 }
@@ -123,6 +133,17 @@ ModuleRepository::getAvailableModules() const
   return os.str();
 }
 
+void
+ModuleRepository::registerOperators(const std::string& module_name)
+{
+  auto i_module = m_module_set.find(module_name);
+  if (i_module != m_module_set.end()) {
+    i_module->second->registerOperators();
+  } else {
+    throw NormalError(std::string{"could not find module "} + module_name);
+  }
+}
+
 std::string
 ModuleRepository::getModuleInfo(const std::string& module_name) const
 {
diff --git a/src/language/modules/ModuleRepository.hpp b/src/language/modules/ModuleRepository.hpp
index c224f6491521ad9757ad5253011604e863a10503..c4c9870fcedf550c82f94374f759f94d4c9cc878 100644
--- a/src/language/modules/ModuleRepository.hpp
+++ b/src/language/modules/ModuleRepository.hpp
@@ -29,6 +29,7 @@ class ModuleRepository
  public:
   void populateSymbolTable(const ASTNode& module_name_node, SymbolTable& symbol_table);
   void populateMandatorySymbolTable(const ASTNode& root_node, SymbolTable& symbol_table);
+  void registerOperators(const std::string& module_name);
 
   std::string getAvailableModules() const;
   std::string getModuleInfo(const std::string& module_name) const;
diff --git a/src/language/modules/SchemeModule.cpp b/src/language/modules/SchemeModule.cpp
index 3051b6bb2265754ed8f1a84b5a1952c59325705b..f0748f27040df92ed0237c510db4a6ed6015de28 100644
--- a/src/language/modules/SchemeModule.cpp
+++ b/src/language/modules/SchemeModule.cpp
@@ -280,3 +280,8 @@ SchemeModule::SchemeModule()
 
                               ));
 }
+
+void
+SchemeModule::registerOperators() const
+{
+}
diff --git a/src/language/modules/SchemeModule.hpp b/src/language/modules/SchemeModule.hpp
index 3cfbb254a8f6e2ac36d16c1a78e53f3f995f56fc..8e5ee95d8f6797e705cba0436829a565c7714e6c 100644
--- a/src/language/modules/SchemeModule.hpp
+++ b/src/language/modules/SchemeModule.hpp
@@ -34,6 +34,8 @@ class SchemeModule : public BuiltinModule
     return "scheme";
   }
 
+  void registerOperators() const final;
+
   SchemeModule();
 
   ~SchemeModule() = default;
diff --git a/src/language/modules/UtilsModule.cpp b/src/language/modules/UtilsModule.cpp
index b74ddc54eaab21ebf44dd53dbb585f4d0111c3fe..44d06e5377500e743172ceea12fe9ddfcd0a7d3e 100644
--- a/src/language/modules/UtilsModule.cpp
+++ b/src/language/modules/UtilsModule.cpp
@@ -65,3 +65,7 @@ UtilsModule::UtilsModule()
 
                               ));
 }
+
+void
+UtilsModule::registerOperators() const
+{}
diff --git a/src/language/modules/UtilsModule.hpp b/src/language/modules/UtilsModule.hpp
index f7580a0422d3d8dabbd8c931b99dbfc7601f84da..620f965eeab4e10bdb7542b9862aa1423d2f48bb 100644
--- a/src/language/modules/UtilsModule.hpp
+++ b/src/language/modules/UtilsModule.hpp
@@ -12,6 +12,8 @@ class UtilsModule : public BuiltinModule
     return "utils";
   }
 
+  void registerOperators() const final;
+
   UtilsModule();
   ~UtilsModule() = default;
 };
diff --git a/src/language/modules/WriterModule.cpp b/src/language/modules/WriterModule.cpp
index 9f2fd98f103ec101190011b7a0ed1ded288ef009..fcb3beb6186b8b6918f1f51efccabb54a657c896 100644
--- a/src/language/modules/WriterModule.cpp
+++ b/src/language/modules/WriterModule.cpp
@@ -100,3 +100,7 @@ WriterModule::WriterModule()
 
                               ));
 }
+
+void
+WriterModule::registerOperators() const
+{}
diff --git a/src/language/modules/WriterModule.hpp b/src/language/modules/WriterModule.hpp
index 14a961d7a812b34aac1c5010ddda674749fdbfb8..adcd92530298a99f088743e7ae6583bc09faa93c 100644
--- a/src/language/modules/WriterModule.hpp
+++ b/src/language/modules/WriterModule.hpp
@@ -29,6 +29,8 @@ class WriterModule : public BuiltinModule
     return "writer";
   }
 
+  void registerOperators() const final;
+
   WriterModule();
 
   ~WriterModule() = default;
diff --git a/src/language/utils/OperatorRepository.cpp b/src/language/utils/OperatorRepository.cpp
index d34344b967f41c72ae09849a554958b8ebfcc1f3..1ab43da119b0c09fe7c2dbe9ae2348bbfbc81996 100644
--- a/src/language/utils/OperatorRepository.cpp
+++ b/src/language/utils/OperatorRepository.cpp
@@ -1,33 +1,5 @@
 #include <language/utils/OperatorRepository.hpp>
 
-#include <language/utils/AffectationProcessorBuilder.hpp>
-#include <language/utils/AffectationRegisterForB.hpp>
-#include <language/utils/AffectationRegisterForN.hpp>
-#include <language/utils/AffectationRegisterForR.hpp>
-#include <language/utils/AffectationRegisterForRn.hpp>
-#include <language/utils/AffectationRegisterForRnxn.hpp>
-#include <language/utils/AffectationRegisterForString.hpp>
-#include <language/utils/AffectationRegisterForZ.hpp>
-
-#include <language/utils/BinaryOperatorRegisterForB.hpp>
-#include <language/utils/BinaryOperatorRegisterForN.hpp>
-#include <language/utils/BinaryOperatorRegisterForR.hpp>
-#include <language/utils/BinaryOperatorRegisterForRn.hpp>
-#include <language/utils/BinaryOperatorRegisterForRnxn.hpp>
-#include <language/utils/BinaryOperatorRegisterForString.hpp>
-#include <language/utils/BinaryOperatorRegisterForZ.hpp>
-
-#include <language/utils/IncDecOperatorRegisterForN.hpp>
-#include <language/utils/IncDecOperatorRegisterForR.hpp>
-#include <language/utils/IncDecOperatorRegisterForZ.hpp>
-
-#include <language/utils/UnaryOperatorRegisterForB.hpp>
-#include <language/utils/UnaryOperatorRegisterForN.hpp>
-#include <language/utils/UnaryOperatorRegisterForR.hpp>
-#include <language/utils/UnaryOperatorRegisterForRn.hpp>
-#include <language/utils/UnaryOperatorRegisterForRnxn.hpp>
-#include <language/utils/UnaryOperatorRegisterForZ.hpp>
-
 #include <utils/PugsAssert.hpp>
 
 OperatorRepository* OperatorRepository::m_instance = nullptr;
@@ -39,7 +11,6 @@ OperatorRepository::reset()
   m_binary_operator_builder_list.clear();
   m_inc_dec_operator_builder_list.clear();
   m_unary_operator_builder_list.clear();
-  this->_initialize();
 }
 
 void
@@ -47,7 +18,6 @@ OperatorRepository::create()
 {
   Assert(m_instance == nullptr, "AffectationRepository was already created");
   m_instance = new OperatorRepository;
-  m_instance->_initialize();
 }
 
 void
@@ -57,46 +27,3 @@ OperatorRepository::destroy()
   delete m_instance;
   m_instance = nullptr;
 }
-
-void
-OperatorRepository::_initialize()
-{
-  AffectationRegisterForB{};
-  AffectationRegisterForN{};
-  AffectationRegisterForZ{};
-  AffectationRegisterForR{};
-  AffectationRegisterForRn<1>{};
-  AffectationRegisterForRn<2>{};
-  AffectationRegisterForRn<3>{};
-  AffectationRegisterForRnxn<1>{};
-  AffectationRegisterForRnxn<2>{};
-  AffectationRegisterForRnxn<3>{};
-  AffectationRegisterForString{};
-
-  BinaryOperatorRegisterForB{};
-  BinaryOperatorRegisterForN{};
-  BinaryOperatorRegisterForZ{};
-  BinaryOperatorRegisterForR{};
-  BinaryOperatorRegisterForRn<1>{};
-  BinaryOperatorRegisterForRn<2>{};
-  BinaryOperatorRegisterForRn<3>{};
-  BinaryOperatorRegisterForRnxn<1>{};
-  BinaryOperatorRegisterForRnxn<2>{};
-  BinaryOperatorRegisterForRnxn<3>{};
-  BinaryOperatorRegisterForString{};
-
-  IncDecOperatorRegisterForN{};
-  IncDecOperatorRegisterForR{};
-  IncDecOperatorRegisterForZ{};
-
-  UnaryOperatorRegisterForB{};
-  UnaryOperatorRegisterForN{};
-  UnaryOperatorRegisterForZ{};
-  UnaryOperatorRegisterForR{};
-  UnaryOperatorRegisterForRn<1>{};
-  UnaryOperatorRegisterForRn<2>{};
-  UnaryOperatorRegisterForRn<3>{};
-  UnaryOperatorRegisterForRnxn<1>{};
-  UnaryOperatorRegisterForRnxn<2>{};
-  UnaryOperatorRegisterForRnxn<3>{};
-}
diff --git a/src/language/utils/OperatorRepository.hpp b/src/language/utils/OperatorRepository.hpp
index 6ac61e6e245f8f545e4794ffb4bd4703d4806b82..cf4b322e7f9da12311a0e1b1dcd47ee0c25e7936 100644
--- a/src/language/utils/OperatorRepository.hpp
+++ b/src/language/utils/OperatorRepository.hpp
@@ -58,8 +58,6 @@ class OperatorRepository
 
   std::unordered_map<std::string, Descriptor<IUnaryOperatorProcessorBuilder>> m_unary_operator_builder_list;
 
-  void _initialize();
-
  public:
   void reset();
 
diff --git a/tests/test_ASTNodeAffectationExpressionBuilder.cpp b/tests/test_ASTNodeAffectationExpressionBuilder.cpp
index b155ab61473f320be06b499e70cc4a32a269ce6f..85c443ebcc807d87ba197bc8f534763fcf46beba 100644
--- a/tests/test_ASTNodeAffectationExpressionBuilder.cpp
+++ b/tests/test_ASTNodeAffectationExpressionBuilder.cpp
@@ -2,6 +2,7 @@
 #include <catch2/matchers/catch_matchers_all.hpp>
 
 #include <language/ast/ASTBuilder.hpp>
+#include <language/ast/ASTModulesImporter.hpp>
 #include <language/ast/ASTNodeAffectationExpressionBuilder.hpp>
 #include <language/ast/ASTNodeDataTypeBuilder.hpp>
 #include <language/ast/ASTNodeDeclarationToAffectationConverter.hpp>
@@ -13,6 +14,7 @@
 #include <language/utils/ASTPrinter.hpp>
 #include <language/utils/BasicAffectationRegistrerFor.hpp>
 #include <language/utils/EmbeddedData.hpp>
+#include <language/utils/OperatorRepository.hpp>
 #include <language/utils/TypeDescriptor.hpp>
 #include <utils/Demangle.hpp>
 #include <utils/Exceptions.hpp>
@@ -27,9 +29,9 @@
                                                                                                                 \
     TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};                                                  \
                                                                                                                 \
-    BasicAffectationRegisterFor<EmbeddedData>{ASTNodeDataType::build<ASTNodeDataType::type_id_t>("builtin_t")}; \
-                                                                                                                \
     auto ast = ASTBuilder::build(input);                                                                        \
+    ASTModulesImporter{*ast};                                                                                   \
+    BasicAffectationRegisterFor<EmbeddedData>{ASTNodeDataType::build<ASTNodeDataType::type_id_t>("builtin_t")}; \
                                                                                                                 \
     ASTSymbolTableBuilder{*ast};                                                                                \
     ASTNodeDataTypeBuilder{*ast};                                                                               \
@@ -43,8 +45,6 @@
     ast_output << '\n' << ASTPrinter{*ast, ASTPrinter::Format::raw, {ASTPrinter::Info::exec_type}};             \
                                                                                                                 \
     REQUIRE(ast_output.str() == expected_output);                                                               \
-                                                                                                                \
-    OperatorRepository::instance().reset();                                                                     \
   }
 
 template <>
@@ -58,10 +58,10 @@ const auto builtin_data_type = ast_node_data_type_from<std::shared_ptr<const dou
     static_assert(std::is_same_v<std::decay_t<decltype(expected_output)>, std::string_view> or                  \
                   std::is_same_v<std::decay_t<decltype(expected_output)>, std::string>);                        \
                                                                                                                 \
-    BasicAffectationRegisterFor<EmbeddedData>{ASTNodeDataType::build<ASTNodeDataType::type_id_t>("builtin_t")}; \
-                                                                                                                \
     TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};                                                  \
     auto ast = ASTBuilder::build(input);                                                                        \
+    ASTModulesImporter{*ast};                                                                                   \
+    BasicAffectationRegisterFor<EmbeddedData>{ASTNodeDataType::build<ASTNodeDataType::type_id_t>("builtin_t")}; \
                                                                                                                 \
     SymbolTable& symbol_table = *ast->m_symbol_table;                                                           \
     auto [i_symbol, success]  = symbol_table.add(builtin_data_type.nameOfTypeId(), ast->begin());               \
@@ -111,6 +111,8 @@ const auto builtin_data_type = ast_node_data_type_from<std::shared_ptr<const dou
                                                                                               \
     TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};                                \
     auto ast = ASTBuilder::build(input);                                                      \
+    OperatorRepository::instance().reset();                                                   \
+    ASTModulesImporter{*ast};                                                                 \
                                                                                               \
     ASTSymbolTableBuilder{*ast};                                                              \
     ASTNodeDataTypeBuilder{*ast};                                                             \
@@ -127,10 +129,12 @@ const auto builtin_data_type = ast_node_data_type_from<std::shared_ptr<const dou
     static_assert(std::is_same_v<std::decay_t<decltype(expected_error)>, std::string_view> or                   \
                   std::is_same_v<std::decay_t<decltype(expected_error)>, std::string>);                         \
                                                                                                                 \
-    BasicAffectationRegisterFor<EmbeddedData>{ASTNodeDataType::build<ASTNodeDataType::type_id_t>("builtin_t")}; \
-                                                                                                                \
     TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};                                                  \
     auto ast = ASTBuilder::build(input);                                                                        \
+    OperatorRepository::instance().reset();                                                                     \
+    ASTModulesImporter{*ast};                                                                                   \
+                                                                                                                \
+    BasicAffectationRegisterFor<EmbeddedData>{ASTNodeDataType::build<ASTNodeDataType::type_id_t>("builtin_t")}; \
                                                                                                                 \
     SymbolTable& symbol_table = *ast->m_symbol_table;                                                           \
     auto [i_symbol, success]  = symbol_table.add(builtin_data_type.nameOfTypeId(), ast->begin());               \
@@ -1795,6 +1799,8 @@ let (x,y,z):R*R*R, (x,y) = (2,3);
 
       TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
       auto ast = ASTBuilder::build(input);
+      OperatorRepository::instance().reset();
+      ASTModulesImporter{*ast};
 
       ASTSymbolTableBuilder{*ast};
       REQUIRE_THROWS_WITH(ASTSymbolInitializationChecker{*ast},
@@ -1810,6 +1816,8 @@ let x:R, (x,y) = (2,3);
 
       TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
       auto ast = ASTBuilder::build(input);
+      OperatorRepository::instance().reset();
+      ASTModulesImporter{*ast};
 
       ASTSymbolTableBuilder{*ast};
       REQUIRE_THROWS_WITH(ASTSymbolInitializationChecker{*ast},
@@ -1825,6 +1833,8 @@ let x:R, y = 3;
 
       TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
       auto ast = ASTBuilder::build(input);
+      OperatorRepository::instance().reset();
+      ASTModulesImporter{*ast};
 
       ASTSymbolTableBuilder{*ast};
       REQUIRE_THROWS_WITH(ASTSymbolInitializationChecker{*ast}, std::string{"invalid identifier, expecting 'x'"});
@@ -1838,6 +1848,8 @@ let (x,y):R, (y,x) = (3,2);
 
       TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
       auto ast = ASTBuilder::build(input);
+      OperatorRepository::instance().reset();
+      ASTModulesImporter{*ast};
 
       ASTSymbolTableBuilder{*ast};
       REQUIRE_THROWS_WITH(ASTSymbolInitializationChecker{*ast}, std::string{"invalid identifier, expecting 'x'"});
diff --git a/tests/test_AffectationProcessor.cpp b/tests/test_AffectationProcessor.cpp
index f64af713bdd5e45ddec46b50869b7fb035b8a0f3..ec130a135320bf1ceba5ee1ff532b57437296d2e 100644
--- a/tests/test_AffectationProcessor.cpp
+++ b/tests/test_AffectationProcessor.cpp
@@ -2,6 +2,7 @@
 #include <catch2/matchers/catch_matchers_all.hpp>
 
 #include <language/ast/ASTBuilder.hpp>
+#include <language/ast/ASTModulesImporter.hpp>
 #include <language/ast/ASTNodeAffectationExpressionBuilder.hpp>
 #include <language/ast/ASTNodeDataTypeBuilder.hpp>
 #include <language/ast/ASTNodeDeclarationToAffectationConverter.hpp>
@@ -20,6 +21,8 @@
     TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};                \
     auto ast = ASTBuilder::build(input);                                      \
                                                                               \
+    ASTModulesImporter{*ast};                                                 \
+                                                                              \
     ASTSymbolTableBuilder{*ast};                                              \
     ASTNodeDataTypeBuilder{*ast};                                             \
                                                                               \
@@ -48,6 +51,8 @@
     TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};          \
     auto ast = ASTBuilder::build(input);                                \
                                                                         \
+    ASTModulesImporter{*ast};                                           \
+                                                                        \
     ASTSymbolTableBuilder{*ast};                                        \
     ASTNodeDataTypeBuilder{*ast};                                       \
                                                                         \