refactor EntityName

EntityName now clearly expresses its double identity:
 - NamedTarget
 - AnonymousTarget

The usage of std::variant<NamedTarget,AnonymousTarget> guarantees that
EntityName, internally, is not a mix of the two - like could happen
before this patch.

NamedTarget features an enum ReferenceType to express the type of the
target, namely, "normal target" or an "explicit file reference".

Thanks to this refactoring, the introduction of new targets type
should be easier, since the design is more modular.

NamedTarget

8 files changed, 230 insertions, 154 deletions

diff --git a/src/buildtool/build_engine/base_maps/entity_name.hpp b/src/buildtool/build_engine/base_maps/entity_name.hpp
index 8f8afd0e..4f1e2189 100644
--- a/src/buildtool/build_engine/base_maps/entity_name.hpp
+++ b/src/buildtool/build_engine/base_maps/entity_name.hpp
@@ -21,13 +21,13 @@ namespace BuildMaps::Base {
         std::nullopt) noexcept -> std::optional<EntityName> {
     try {
         if (json.is_string()) {
-            return EntityName{current.repository,
-                              current.module,
-                              json.template get<std::string>()};
+            const auto& x = current.GetNamedTarget();
+            return EntityName{
+                x.repository, x.module, json.template get<std::string>()};
         }
         if (json.is_array() and json.size() == 2 and json[0].is_string() and
             json[1].is_string()) {
-            return EntityName{current.repository,
+            return EntityName{current.GetNamedTarget().repository,
                               json[0].template get<std::string>(),
                               json[1].template get<std::string>()};
         }
@@ -37,14 +37,16 @@ namespace BuildMaps::Base {
             json[2].is_string()) {
             auto name = json[2].template get<std::string>();
             if (json[1].is_null()) {
+                const auto& x = current.GetNamedTarget();
                 return EntityName{
-                    current.repository, current.module, name, true};
+                    x.repository, x.module, name, ReferenceType::kFile};
             }
             if (json[1].is_string()) {
                 auto middle = json[1].template get<std::string>();
-                if (middle == "." or middle == current.module) {
+                const auto& x = current.GetNamedTarget();
+                if (middle == "." or middle == x.module) {
                     return EntityName{
-                        current.repository, current.module, name, true};
+                        x.repository, x.module, name, ReferenceType::kFile};
                 }
             }
             if (logger) {
@@ -61,10 +63,11 @@ namespace BuildMaps::Base {
             auto relmodule = json[1].template get<std::string>();
             auto name = json[2].template get<std::string>();
 
-            std::filesystem::path m{current.module};
+            std::filesystem::path m{current.GetNamedTarget().module};
             auto module = (m / relmodule).lexically_normal().string();
             if (module.compare(0, 3, "../") != 0) {
-                return EntityName{current.repository, module, name};
+                return EntityName{
+                    current.GetNamedTarget().repository, module, name};
             }
             if (logger) {
                 (*logger)(fmt::format(
@@ -91,7 +94,7 @@ namespace BuildMaps::Base {
             auto module = json[2].template get<std::string>();
             auto target = json[3].template get<std::string>();
             auto const* repo_name = RepositoryConfig::Instance().GlobalName(
-                current.repository, local_repo_name);
+                current.GetNamedTarget().repository, local_repo_name);
             if (repo_name != nullptr) {
                 return EntityName{*repo_name, module, target};
             }
@@ -117,31 +120,35 @@ namespace BuildMaps::Base {
     try {
         if (expr) {
             if (expr->IsString()) {
-                return EntityName{current.repository,
-                                  current.module,
-                                  expr->Value<std::string>()->get()};
+                const auto& x = current.GetNamedTarget();
+                return EntityName{
+                    x.repository, x.module, expr->Value<std::string>()->get()};
             }
             if (expr->IsList()) {
                 auto const& list = expr->Value<Expression::list_t>()->get();
                 if (list.size() == 2 and list[0]->IsString() and
                     list[1]->IsString()) {
-                    return EntityName{current.repository,
-                                      list[0]->Value<std::string>()->get(),
-                                      list[1]->Value<std::string>()->get()};
+                    return EntityName{
+                        NamedTarget{current.GetNamedTarget().repository,
+                                    list[0]->Value<std::string>()->get(),
+                                    list[1]->Value<std::string>()->get()}};
                 }
                 if (list.size() == 3 and list[0]->IsString() and
                     list[0]->String() == EntityName::kFileLocationMarker and
                     list[2]->IsString()) {
                     auto name = list[2]->Value<std::string>()->get();
                     if (list[1]->IsNone()) {
+                        const auto& x = current.GetNamedTarget();
                         return EntityName{
-                            current.repository, current.module, name, true};
+                            x.repository, x.module, name, ReferenceType::kFile};
                     }
                     if (list[1]->IsString() and
                         (list[1]->String() == "." or
-                         list[1]->String() == current.module)) {
+                         list[1]->String() ==
+                             current.GetNamedTarget().module)) {
+                        const auto& x = current.GetNamedTarget();
                         return EntityName{
-                            current.repository, current.module, name, true};
+                            x.repository, x.module, name, ReferenceType::kFile};
                     }
                     if (logger) {
                         (*logger)(fmt::format(
@@ -153,12 +160,14 @@ namespace BuildMaps::Base {
                          list[0]->String() ==
                              EntityName::kRelativeLocationMarker and
                          list[1]->IsString() and list[2]->IsString()) {
-                    std::filesystem::path m{current.module};
+                    std::filesystem::path m{current.GetNamedTarget().module};
                     auto module =
                         (m / (list[1]->String())).lexically_normal().string();
                     if (module.compare(0, 3, "../") != 0) {
                         return EntityName{
-                            current.repository, module, list[2]->String()};
+                            NamedTarget{current.GetNamedTarget().repository,
+                                        module,
+                                        list[2]->String()}};
                     }
                     if (logger) {
                         (*logger)(fmt::format(
@@ -178,7 +187,8 @@ namespace BuildMaps::Base {
                          list[3]->IsString()) {
                     auto const* repo_name =
                         RepositoryConfig::Instance().GlobalName(
-                            current.repository, list[1]->String());
+                            current.GetNamedTarget().repository,
+                            list[1]->String());
                     if (repo_name != nullptr) {
                         return EntityName{
                             *repo_name, list[2]->String(), list[3]->String()};
diff --git a/src/buildtool/build_engine/base_maps/entity_name_data.hpp b/src/buildtool/build_engine/base_maps/entity_name_data.hpp
index 217ccfb5..7aa17db1 100644
--- a/src/buildtool/build_engine/base_maps/entity_name_data.hpp
+++ b/src/buildtool/build_engine/base_maps/entity_name_data.hpp
@@ -4,6 +4,7 @@
 #include <filesystem>
 #include <optional>
 #include <utility>
+#include <variant>
 
 #include "nlohmann/json.hpp"
 #include "src/buildtool/build_engine/base_maps/module_name.hpp"
@@ -23,27 +24,22 @@ struct AnonymousTarget {
     }
 };
 
-struct EntityName {
-    static constexpr auto kLocationMarker = "@";
-    static constexpr auto kFileLocationMarker = "FILE";
-    static constexpr auto kRelativeLocationMarker = "./";
-    static constexpr auto kAnonymousMarker = "#";
+enum class ReferenceType : std::int8_t { kTarget, kFile };
 
+struct NamedTarget {
     std::string repository{};
     std::string module{};
     std::string name{};
-    std::optional<AnonymousTarget> anonymous{};
-    bool explicit_file_reference{};
-
-    EntityName() = default;
-    EntityName(std::string repository,
-               const std::string& module,
-               std::string name)
+    ReferenceType reference_t{ReferenceType::kTarget};
+    NamedTarget() = default;
+    NamedTarget(std::string repository,
+                std::string const& module,
+                std::string name,
+                ReferenceType reference_type = ReferenceType::kTarget)
         : repository{std::move(repository)},
           module{normal_module_name(module)},
-          name{std::move(name)} {}
-    explicit EntityName(AnonymousTarget anonymous)
-        : anonymous{std::move(anonymous)} {}
+          name{std::move(name)},
+          reference_t{reference_type} {}
 
     static auto normal_module_name(const std::string& module) -> std::string {
         return std::filesystem::path("/" + module + "/")
@@ -52,29 +48,75 @@ struct EntityName {
             .parent_path()
             .string();
     }
+    [[nodiscard]] friend auto operator==(NamedTarget const& x,
+                                         NamedTarget const& y) -> bool {
+        return x.repository == y.repository && x.module == y.module &&
+               x.name == y.name && x.reference_t == y.reference_t;
+    }
+    [[nodiscard]] friend auto operator!=(NamedTarget const& x,
+                                         NamedTarget const& y) -> bool {
+        return not(x == y);
+    }
+};
 
-    [[nodiscard]] auto operator==(
-        BuildMaps::Base::EntityName const& other) const noexcept -> bool {
-        return module == other.module && name == other.name &&
-               repository == other.repository && anonymous == other.anonymous &&
-               explicit_file_reference == other.explicit_file_reference;
+class EntityName {
+  public:
+    using variant_t = std::variant<NamedTarget, AnonymousTarget>;
+    static constexpr auto kLocationMarker = "@";
+    static constexpr auto kFileLocationMarker = "FILE";
+    static constexpr auto kRelativeLocationMarker = "./";
+    static constexpr auto kAnonymousMarker = "#";
+
+    EntityName() : EntityName{NamedTarget{}} {}
+    explicit EntityName(variant_t x) : entity_name_{std::move(x)} {}
+    EntityName(std::string repository,
+               const std::string& module,
+               std::string name,
+               ReferenceType reference_type = ReferenceType::kTarget)
+        : EntityName{NamedTarget{std::move(repository),
+                                 module,
+                                 std::move(name),
+                                 reference_type}} {}
+
+    friend auto operator==(EntityName const& a, EntityName const& b) -> bool {
+        return a.entity_name_ == b.entity_name_;
+    }
+    [[nodiscard]] auto IsAnonymousTarget() const -> bool {
+        return std::holds_alternative<AnonymousTarget>(entity_name_);
+    }
+    [[nodiscard]] auto IsNamedTarget() const -> bool {
+        return std::holds_alternative<NamedTarget>(entity_name_);
+    }
+    [[nodiscard]] auto GetAnonymousTarget() -> AnonymousTarget& {
+        return std::get<AnonymousTarget>(entity_name_);
+    }
+    [[nodiscard]] auto GetNamedTarget() -> NamedTarget& {
+        return std::get<NamedTarget>(entity_name_);
+    }
+    [[nodiscard]] auto GetAnonymousTarget() const -> AnonymousTarget const& {
+        return std::get<AnonymousTarget>(entity_name_);
+    }
+    [[nodiscard]] auto GetNamedTarget() const -> NamedTarget const& {
+        return std::get<NamedTarget>(entity_name_);
     }
 
     [[nodiscard]] auto ToJson() const -> nlohmann::json {
         nlohmann::json j;
         if (IsAnonymousTarget()) {
             j.push_back(kAnonymousMarker);
-            j.push_back(anonymous->rule_map.ToIdentifier());
-            j.push_back(anonymous->target_node.ToIdentifier());
+            const auto& x = GetAnonymousTarget();
+            j.push_back(x.rule_map.ToIdentifier());
+            j.push_back(x.target_node.ToIdentifier());
         }
         else {
             j.push_back(kLocationMarker);
-            j.push_back(repository);
-            if (explicit_file_reference) {
+            const auto& x = GetNamedTarget();
+            j.push_back(x.repository);
+            if (x.reference_t == ReferenceType::kFile) {
                 j.push_back(kFileLocationMarker);
             }
-            j.push_back(module);
-            j.push_back(name);
+            j.push_back(x.module);
+            j.push_back(x.name);
         }
         return j;
     }
@@ -84,45 +126,54 @@ struct EntityName {
     }
 
     [[nodiscard]] auto ToModule() const -> ModuleName {
-        return ModuleName{repository, module};
+        const auto& x = GetNamedTarget();
+        return ModuleName{x.repository, x.module};
     }
 
     [[nodiscard]] auto IsDefinitionName() const -> bool {
-        return (not explicit_file_reference);
-    }
-
-    [[nodiscard]] auto IsAnonymousTarget() const -> bool {
-        return static_cast<bool>(anonymous);
+        return GetNamedTarget().reference_t == ReferenceType::kTarget;
     }
 
-    EntityName(std::string repository,
-               const std::string& module,
-               std::string name,
-               bool explicit_file_reference)
-        : repository{std::move(repository)},
-          module{normal_module_name(module)},
-          name{std::move(name)},
-          explicit_file_reference{explicit_file_reference} {}
+  private:
+    variant_t entity_name_;
 };
 }  // namespace BuildMaps::Base
 
 namespace std {
 template <>
-struct hash<BuildMaps::Base::EntityName> {
+struct hash<BuildMaps::Base::NamedTarget> {
     [[nodiscard]] auto operator()(
-        const BuildMaps::Base::EntityName& t) const noexcept -> std::size_t {
+        const BuildMaps::Base::NamedTarget& t) const noexcept -> std::size_t {
         size_t seed{};
         hash_combine<std::string>(&seed, t.repository);
         hash_combine<std::string>(&seed, t.module);
         hash_combine<std::string>(&seed, t.name);
-        auto anonymous =
-            t.anonymous.value_or(BuildMaps::Base::AnonymousTarget{});
-        hash_combine<ExpressionPtr>(&seed, anonymous.rule_map);
-        hash_combine<ExpressionPtr>(&seed, anonymous.target_node);
-        hash_combine<bool>(&seed, t.explicit_file_reference);
+        hash_combine<std::int8_t>(&seed,
+                                  static_cast<std::int8_t>(t.reference_t));
         return seed;
     }
 };
+template <>
+struct hash<BuildMaps::Base::AnonymousTarget> {
+    [[nodiscard]] auto operator()(const BuildMaps::Base::AnonymousTarget& t)
+        const noexcept -> std::size_t {
+        size_t seed{};
+        hash_combine<ExpressionPtr>(&seed, t.rule_map);
+        hash_combine<ExpressionPtr>(&seed, t.target_node);
+        return seed;
+    }
+};
+template <>
+struct hash<BuildMaps::Base::EntityName> {
+    [[nodiscard]] auto operator()(
+        const BuildMaps::Base::EntityName& t) const noexcept -> std::size_t {
+        if (t.IsAnonymousTarget()) {
+            return hash<BuildMaps::Base::AnonymousTarget>{}(
+                t.GetAnonymousTarget());
+        }
+        return hash<BuildMaps::Base::NamedTarget>{}(t.GetNamedTarget());
+    }
+};
 
 }  // namespace std
 
diff --git a/src/buildtool/build_engine/base_maps/expression_map.cpp b/src/buildtool/build_engine/base_maps/expression_map.cpp
index df464b15..4274674e 100644
--- a/src/buildtool/build_engine/base_maps/expression_map.cpp
+++ b/src/buildtool/build_engine/base_maps/expression_map.cpp
@@ -29,11 +29,12 @@ auto CreateExpressionMap(gsl::not_null<ExpressionFileMap*> const& expr_file_map,
              logger,
              subcaller = std::move(subcaller),
              id](auto json_values) {
-                auto func_it = json_values[0]->find(id.name);
+                auto const& target_ = id.GetNamedTarget();
+                auto func_it = json_values[0]->find(target_.name);
                 if (func_it == json_values[0]->end()) {
                     (*logger)(fmt::format("Cannot find expression {} in {}",
-                                          id.name,
-                                          id.module),
+                                          target_.name,
+                                          target_.module),
                               true);
                     return;
                 }
@@ -79,7 +80,7 @@ auto CreateExpressionMap(gsl::not_null<ExpressionFileMap*> const& expr_file_map,
             },
             [logger, id](auto msg, auto fatal) {
                 (*logger)(fmt::format("While reading expression file in {}: {}",
-                                      id.module,
+                                      id.GetNamedTarget().module,
                                       msg),
                           fatal);
             });
diff --git a/src/buildtool/build_engine/base_maps/field_reader.hpp b/src/buildtool/build_engine/base_maps/field_reader.hpp
index 15653fdc..f2465da9 100644
--- a/src/buildtool/build_engine/base_maps/field_reader.hpp
+++ b/src/buildtool/build_engine/base_maps/field_reader.hpp
@@ -57,10 +57,10 @@ class FieldReader {
                                      AsyncMapConsumerLoggerPtr const& logger)
         -> std::optional<FieldReader> {
         if (not json.is_object()) {
-            (*logger)(
-                fmt::format(
-                    "{} definition {} is not an object.", entity_type, id.name),
-                true);
+            (*logger)(fmt::format("{} definition {} is not an object.",
+                                  entity_type,
+                                  id.GetNamedTarget().name),
+                      true);
             return std::nullopt;
         }
         return FieldReader(json, id, entity_type, logger);
@@ -72,10 +72,10 @@ class FieldReader {
                                         AsyncMapConsumerLoggerPtr const& logger)
         -> Ptr {
         if (not json.is_object()) {
-            (*logger)(
-                fmt::format(
-                    "{} definition {} is not an object.", entity_type, id.name),
-                true);
+            (*logger)(fmt::format("{} definition {} is not an object.",
+                                  entity_type,
+                                  id.GetNamedTarget().name),
+                      true);
             return nullptr;
         }
         return std::make_shared<FieldReader>(json, id, entity_type, logger);
@@ -88,7 +88,7 @@ class FieldReader {
             (*logger_)(fmt::format("Missing mandatory field {} in {} {}.",
                                    field_name,
                                    entity_type_,
-                                   id_.name),
+                                   id_.GetNamedTarget().name),
                        true);
             return ExpressionPtr{nullptr};
         }
@@ -129,7 +129,7 @@ class FieldReader {
             (*logger_)(fmt::format("Field {} in {} {} is not a list",
                                    field_name,
                                    entity_type_,
-                                   id_.name),
+                                   id_.GetNamedTarget().name),
                        true);
             return std::nullopt;
         }
@@ -147,7 +147,7 @@ class FieldReader {
             (*logger_)(fmt::format("List entry in {} of {} {} is not a string",
                                    field_name,
                                    entity_type_,
-                                   id_.name),
+                                   id_.GetNamedTarget().name),
                        true);
             return std::nullopt;
         }
@@ -163,7 +163,7 @@ class FieldReader {
             (*logger_)(fmt::format("Field {} in {} {} is not an object",
                                    field_name,
                                    entity_type_,
-                                   id_.name),
+                                   id_.GetNamedTarget().name),
                        true);
             return std::nullopt;
         }
@@ -182,7 +182,7 @@ class FieldReader {
                                            entry,
                                            field_name,
                                            entity_type_,
-                                           id_.name,
+                                           id_.GetNamedTarget().name,
                                            parse_err),
                                true);
                 });
diff --git a/src/buildtool/build_engine/base_maps/rule_map.cpp b/src/buildtool/build_engine/base_maps/rule_map.cpp
index 67612172..7b9d9cf4 100644
--- a/src/buildtool/build_engine/base_maps/rule_map.cpp
+++ b/src/buildtool/build_engine/base_maps/rule_map.cpp
@@ -33,9 +33,9 @@ auto const kRuleFields = std::unordered_set<std::string>{"anonymous",
     -> std::optional<UserRule::anonymous_defs_t> {
     auto obj = GetOrDefault(json, "anonymous", nlohmann::json::object());
     if (not obj.is_object()) {
-        (*logger)(
-            fmt::format("Field anonymous in rule {} is not an object", id.name),
-            true);
+        (*logger)(fmt::format("Field anonymous in rule {} is not an object",
+                              id.GetNamedTarget().name),
+                  true);
         return std::nullopt;
     }
 
@@ -46,7 +46,7 @@ auto const kRuleFields = std::unordered_set<std::string>{"anonymous",
             (*logger)(fmt::format("Entry {} in field anonymous in rule {} is "
                                   "not an object",
                                   name,
-                                  id.name),
+                                  id.GetNamedTarget().name),
                       true);
             return std::nullopt;
         }
@@ -56,7 +56,7 @@ auto const kRuleFields = std::unordered_set<std::string>{"anonymous",
             (*logger)(fmt::format("Entry target for {} in field anonymous in "
                                   "rule {} is missing",
                                   name,
-                                  id.name),
+                                  id.GetNamedTarget().name),
                       true);
             return std::nullopt;
         }
@@ -64,7 +64,7 @@ auto const kRuleFields = std::unordered_set<std::string>{"anonymous",
             (*logger)(fmt::format("Entry target for {} in field anonymous in "
                                   "rule {} is not a string",
                                   name,
-                                  id.name),
+                                  id.GetNamedTarget().name),
                       true);
             return std::nullopt;
         }
@@ -74,7 +74,7 @@ auto const kRuleFields = std::unordered_set<std::string>{"anonymous",
             (*logger)(fmt::format("Entry provider for {} in field anonymous in "
                                   "rule {} is missing",
                                   name,
-                                  id.name),
+                                  id.GetNamedTarget().name),
                       true);
             return std::nullopt;
         }
@@ -82,7 +82,7 @@ auto const kRuleFields = std::unordered_set<std::string>{"anonymous",
             (*logger)(fmt::format("Entry provider for {} in field anonymous in "
                                   "rule {} is not a string",
                                   name,
-                                  id.name),
+                                  id.GetNamedTarget().name),
                       true);
             return std::nullopt;
         }
@@ -92,7 +92,7 @@ auto const kRuleFields = std::unordered_set<std::string>{"anonymous",
             (*logger)(fmt::format("Entry rule_map for {} in field anonymous in "
                                   "rule {} is missing",
                                   name,
-                                  id.name),
+                                  id.GetNamedTarget().name),
                       true);
             return std::nullopt;
         }
@@ -100,7 +100,7 @@ auto const kRuleFields = std::unordered_set<std::string>{"anonymous",
             (*logger)(fmt::format("Entry rule_map for {} in field anonymous in "
                                   "rule {} is not an object",
                                   name,
-                                  id.name),
+                                  id.GetNamedTarget().name),
                       true);
             return std::nullopt;
         }
@@ -113,7 +113,7 @@ auto const kRuleFields = std::unordered_set<std::string>{"anonymous",
                         fmt::format("Parsing rule name for entry {} in field "
                                     "anonymous in rule {} failed with:\n{}",
                                     name,
-                                    id.name,
+                                    id.GetNamedTarget().name,
                                     msg),
                         true);
                 });
@@ -139,9 +139,9 @@ auto const kRuleFields = std::unordered_set<std::string>{"anonymous",
     -> std::optional<UserRule::implicit_t> {
     auto map = GetOrDefault(json, "implicit", nlohmann::json::object());
     if (not map.is_object()) {
-        (*logger)(
-            fmt::format("Field implicit in rule {} is not an object", id.name),
-            true);
+        (*logger)(fmt::format("Field implicit in rule {} is not an object",
+                              id.GetNamedTarget().name),
+                  true);
         return std::nullopt;
     }
 
@@ -152,7 +152,7 @@ auto const kRuleFields = std::unordered_set<std::string>{"anonymous",
         if (not val.is_array()) {
             (*logger)(fmt::format("Entry in implicit field of rule {} is not a "
                                   "list.",
-                                  id.name),
+                                  id.GetNamedTarget().name),
                       true);
             return std::nullopt;
         }
@@ -164,7 +164,7 @@ auto const kRuleFields = std::unordered_set<std::string>{"anonymous",
                     (*logger)(fmt::format("Parsing entry {} in implicit field "
                                           "of rule {} failed with:\n{}",
                                           item.dump(),
-                                          id.name,
+                                          id.GetNamedTarget().name,
                                           parse_err),
                               true);
                 });
@@ -190,7 +190,7 @@ auto const kRuleFields = std::unordered_set<std::string>{"anonymous",
     if (not map.is_object()) {
         (*logger)(
             fmt::format("Field config_transitions in rule {} is not an object",
-                        id.name),
+                        id.GetNamedTarget().name),
             true);
         return std::nullopt;
     }
@@ -204,7 +204,7 @@ auto const kRuleFields = std::unordered_set<std::string>{"anonymous",
             (*logger)(fmt::format("Failed to create expression for entry {} in "
                                   "config_transitions list of rule {}.",
                                   key,
-                                  id.name),
+                                  id.GetNamedTarget().name),
                       true);
             return std::nullopt;
         }
@@ -235,12 +235,14 @@ auto CreateRuleMap(gsl::not_null<RuleFileMap*> const& rule_file_map,
             {id.ToModule()},
             [ts, expr_map, setter = std::move(setter), logger, id](
                 auto json_values) {
-                auto rule_it = json_values[0]->find(id.name);
+                const auto& target_ = id.GetNamedTarget();
+                auto rule_it = json_values[0]->find(target_.name);
                 if (rule_it == json_values[0]->end()) {
-                    (*logger)(fmt::format("Cannot find rule {} in {}",
-                                          nlohmann::json(id.name).dump(),
-                                          nlohmann::json(id.module).dump()),
-                              true);
+                    (*logger)(
+                        fmt::format("Cannot find rule {} in {}",
+                                    nlohmann::json(target_.name).dump(),
+                                    nlohmann::json(target_.module).dump()),
+                        true);
                     return;
                 }
 
@@ -352,17 +354,17 @@ auto CreateRuleMap(gsl::not_null<RuleFileMap*> const& rule_file_map,
                     [logger, id](auto msg, auto fatal) {
                         (*logger)(fmt::format("While reading expression map "
                                               "for rule {} in {}: {}",
-                                              id.name,
-                                              id.module,
+                                              id.GetNamedTarget().name,
+                                              id.GetNamedTarget().module,
                                               msg),
                                   fatal);
                     });
             },
             [logger, id](auto msg, auto fatal) {
-                (*logger)(
-                    fmt::format(
-                        "While reading rule file in {}: {}", id.module, msg),
-                    fatal);
+                (*logger)(fmt::format("While reading rule file in {}: {}",
+                                      id.GetNamedTarget().module,
+                                      msg),
+                          fatal);
             });
     };
     return UserRuleMap{user_rule_creator, jobs};
diff --git a/src/buildtool/build_engine/base_maps/source_map.cpp b/src/buildtool/build_engine/base_maps/source_map.cpp
index 6a6d49c0..39976016 100644
--- a/src/buildtool/build_engine/base_maps/source_map.cpp
+++ b/src/buildtool/build_engine/base_maps/source_map.cpp
@@ -13,8 +13,8 @@ namespace {
 
 auto as_target(const BuildMaps::Base::EntityName& key, ExpressionPtr artifact)
     -> AnalysedTargetPtr {
-    auto stage =
-        ExpressionPtr{Expression::map_t{key.name, std::move(artifact)}};
+    auto stage = ExpressionPtr{
+        Expression::map_t{key.GetNamedTarget().name, std::move(artifact)}};
     return std::make_shared<AnalysedTarget>(
         TargetResult{stage, Expression::kEmptyMap, stage},
         std::vector<ActionDescription::Ptr>{},
@@ -34,43 +34,46 @@ auto CreateSourceTargetMap(const gsl::not_null<DirectoryEntriesMap*>& dirs,
                                     auto /* unused */,
                                     auto const& key) {
         using std::filesystem::path;
-        auto name = path(key.name).lexically_normal();
+        const auto& target = key.GetNamedTarget();
+        auto name = path(target.name).lexically_normal();
         if (name.is_absolute() or *name.begin() == "..") {
             (*logger)(
                 fmt::format("Source file reference outside current module: {}",
-                            key.name),
+                            target.name),
                 true);
             return;
         }
-        auto dir = (path(key.module) / name).parent_path();
+        auto dir = (path(target.module) / name).parent_path();
         auto const* ws_root =
-            RepositoryConfig::Instance().WorkspaceRoot(key.repository);
+            RepositoryConfig::Instance().WorkspaceRoot(target.repository);
 
         auto src_file_reader = [ts, key, name, setter, logger, dir, ws_root](
                                    bool exists_in_ws_root) {
             if (ws_root != nullptr and exists_in_ws_root) {
                 if (auto desc = ws_root->ToArtifactDescription(
-                        path(key.module) / name, key.repository)) {
+                        path(key.GetNamedTarget().module) / name,
+                        key.GetNamedTarget().repository)) {
                     (*setter)(as_target(key, ExpressionPtr{std::move(*desc)}));
                     return;
                 }
             }
-            (*logger)(fmt::format("Cannot determine source file {}",
-                                  path(key.name).filename().string()),
+            (*logger)(fmt::format(
+                          "Cannot determine source file {}",
+                          path(key.GetNamedTarget().name).filename().string()),
                       true);
         };
 
         if (ws_root != nullptr and ws_root->HasFastDirectoryLookup()) {
             // by-pass directory map and directly attempt to read from ws_root
-            src_file_reader(ws_root->IsFile(path(key.module) / name));
+            src_file_reader(ws_root->IsFile(path(target.module) / name));
             return;
         }
         dirs->ConsumeAfterKeysReady(
             ts,
-            {ModuleName{key.repository, dir.string()}},
+            {ModuleName{target.repository, dir.string()}},
             [key, src_file_reader](auto values) {
-                src_file_reader(
-                    values[0]->Contains(path(key.name).filename().string()));
+                src_file_reader(values[0]->Contains(
+                    path(key.GetNamedTarget().name).filename().string()));
             },
             [logger, dir](auto msg, auto fatal) {
                 (*logger)(
diff --git a/src/buildtool/build_engine/target_map/target_map.cpp b/src/buildtool/build_engine/target_map/target_map.cpp
index 62ab8c91..2e4663da 100644
--- a/src/buildtool/build_engine/target_map/target_map.cpp
+++ b/src/buildtool/build_engine/target_map/target_map.cpp
@@ -1094,7 +1094,7 @@ void withTargetsFile(
     const BuildMaps::Target::TargetMap::SetterPtr& setter,
     const BuildMaps::Target::TargetMap::LoggerPtr& logger,
     const gsl::not_null<BuildMaps::Target::ResultTargetMap*> result_map) {
-    auto desc_it = targets_file.find(key.target.name);
+    auto desc_it = targets_file.find(key.target.GetNamedTarget().name);
     if (desc_it == targets_file.end()) {
         // Not a defined taraget, treat as source target
         source_target->ConsumeAfterKeysReady(
@@ -1203,8 +1203,9 @@ void withTargetNode(
     const BuildMaps::Target::TargetMap::SetterPtr& setter,
     const BuildMaps::Target::TargetMap::LoggerPtr& logger,
     const gsl::not_null<BuildMaps::Target::ResultTargetMap*> result_map) {
-    auto const& target_node = key.target.anonymous->target_node->Node();
-    auto const& rule_mapping = key.target.anonymous->rule_map->Map();
+    auto const& target_node =
+        key.target.GetAnonymousTarget().target_node->Node();
+    auto const& rule_mapping = key.target.GetAnonymousTarget().rule_map->Map();
     if (target_node.IsValue()) {
         // fixed value node, create analysed target from result
         auto const& val = target_node.GetValue();
@@ -1216,10 +1217,11 @@ void withTargetNode(
         auto const& abs = target_node.GetAbstract();
         auto rule_name = rule_mapping.Find(abs.node_type);
         if (not rule_name) {
-            (*logger)(fmt::format("Cannot resolve type of node {} via rule map "
-                                  "{}",
-                                  target_node.ToString(),
-                                  key.target.anonymous->rule_map->ToString()),
+            (*logger)(fmt::format(
+                          "Cannot resolve type of node {} via rule map "
+                          "{}",
+                          target_node.ToString(),
+                          key.target.GetAnonymousTarget().rule_map->ToString()),
                       /*fatal=*/true);
         }
         rule_map->ConsumeAfterKeysReady(
@@ -1233,7 +1235,10 @@ void withTargetNode(
              result_map,
              rn = rule_name->get()](auto values) {
                 auto data = TargetData::FromTargetNode(
-                    *values[0], abs, key.target.anonymous->rule_map, logger);
+                    *values[0],
+                    abs,
+                    key.target.GetAnonymousTarget().rule_map,
+                    logger);
                 if (not data) {
                     (*logger)(fmt::format("Failed to read data from target {} "
                                           "with rule {}",
@@ -1281,7 +1286,12 @@ auto CreateTargetMap(
     auto target_reader =
         [source_target_map, targets_file_map, rule_map, result_map](
             auto ts, auto setter, auto logger, auto subcaller, auto key) {
-            if (key.target.explicit_file_reference) {
+            if (key.target.IsAnonymousTarget()) {
+                withTargetNode(
+                    key, rule_map, ts, subcaller, setter, logger, result_map);
+            }
+            else if (key.target.GetNamedTarget().reference_t ==
+                     BuildMaps::Base::ReferenceType::kFile) {
                 // Not a defined target, treat as source target
                 source_target_map->ConsumeAfterKeysReady(
                     ts,
@@ -1297,10 +1307,6 @@ auto CreateTargetMap(
                                   fatal);
                     });
             }
-            else if (key.target.IsAnonymousTarget()) {
-                withTargetNode(
-                    key, rule_map, ts, subcaller, setter, logger, result_map);
-            }
             else {
                 targets_file_map->ConsumeAfterKeysReady(
                     ts,
diff --git a/src/buildtool/main/main.cpp b/src/buildtool/main/main.cpp
index 0aeca7b8..a28ff14f 100644
--- a/src/buildtool/main/main.cpp
+++ b/src/buildtool/main/main.cpp
@@ -297,7 +297,7 @@ void SetupLocalExecution(EndpointArguments const& eargs,
     if (clargs.target) {
         auto entity = Base::ParseEntityNameFromJson(
             *clargs.target,
-            Base::EntityName{main_repo, current_module, ""},
+            Base::EntityName{Base::NamedTarget{main_repo, current_module, ""}},
             [&clargs](std::string const& parse_err) {
                 Logger::Log(LogLevel::Error,
                             "Parsing target name {} failed with:\n{}.",
@@ -331,7 +331,8 @@ void SetupLocalExecution(EndpointArguments const& eargs,
         std::exit(kExitFailure);
     }
     return Target::ConfiguredTarget{
-        Base::EntityName{main_repo, current_module, json.begin().key()},
+        Base::EntityName{
+            Base::NamedTarget{main_repo, current_module, json.begin().key()}},
         std::move(config)};
 }
 
@@ -777,14 +778,16 @@ void DumpTargets(std::string const& file_path,
     auto conf_list =
         [&repo_map](Base::EntityName const& ref) -> nlohmann::json& {
         if (ref.IsAnonymousTarget()) {
+            auto const& anon = ref.GetAnonymousTarget();
             auto& anon_map = repo_map[Base::EntityName::kAnonymousMarker];
-            auto& rule_map = anon_map[ref.anonymous->rule_map.ToIdentifier()];
-            return rule_map[ref.anonymous->target_node.ToIdentifier()];
+            auto& rule_map = anon_map[anon.rule_map.ToIdentifier()];
+            return rule_map[anon.target_node.ToIdentifier()];
         }
+        auto const& named = ref.GetNamedTarget();
         auto& location_map = repo_map[Base::EntityName::kLocationMarker];
-        auto& module_map = location_map[ref.repository];
-        auto& target_map = module_map[ref.module];
-        return target_map[ref.name];
+        auto& module_map = location_map[named.repository];
+        auto& target_map = module_map[named.module];
+        return target_map[named.name];
     };
     std::for_each(
         target_ids.begin(), target_ids.end(), [&conf_list](auto const& id) {
@@ -851,10 +854,10 @@ void DumpAnonymous(std::string const& file_path,
     std::for_each(
         target_ids.begin(), target_ids.end(), [&anon_map](auto const& id) {
             if (id.target.IsAnonymousTarget()) {
-                DumpExpressionToMap(&anon_map["rule_maps"],
-                                    id.target.anonymous->rule_map);
+                auto const& anon_t = id.target.GetAnonymousTarget();
+                DumpExpressionToMap(&anon_map["rule_maps"], anon_t.rule_map);
                 DumpNodesInExpressionToMap(&anon_map["nodes"],
-                                           id.target.anonymous->target_node);
+                                           anon_t.target_node);
             }
         });
     auto const dump_string = IndentListsOnlyUntilDepth(anon_map, 2);
@@ -1016,7 +1019,7 @@ auto DescribeTarget(std::string const& main_repo,
                     std::size_t jobs,
                     AnalysisArguments const& clargs) -> int {
     auto id = ReadConfiguredTarget(clargs, main_repo, main_ws_root);
-    if (id.target.explicit_file_reference) {
+    if (id.target.GetNamedTarget().reference_t == Base::ReferenceType::kFile) {
         std::cout << id.ToString() << " is a source file." << std::endl;
         return kExitSuccess;
     }
@@ -1039,7 +1042,7 @@ auto DescribeTarget(std::string const& main_repo,
     if (failed) {
         return kExitFailure;
     }
-    auto desc_it = targets_file.find(id.target.name);
+    auto desc_it = targets_file.find(id.target.GetNamedTarget().name);
     if (desc_it == targets_file.end()) {
         std::cout << id.ToString() << " is implicitly a source file."
                   << std::endl;
@@ -1105,7 +1108,7 @@ auto DescribeTarget(std::string const& main_repo,
     if (failed) {
         return kExitFailure;
     }
-    auto ruledesc_it = rules_file.find(rule_name->name);
+    auto ruledesc_it = rules_file.find(rule_name->GetNamedTarget().name);
     if (ruledesc_it == rules_file.end()) {
         Logger::Log(LogLevel::Error,
                     "Rule definition of {} is missing",