Names coming from query::FindTargets(): assemble directly.

Instead of using ParseFrom(), always assemble names coming from
name = ... values directly with current package. This makes parsing
target that have slashes in it (foo:bar/baz) robust.

bant/explore/aliased-by.cc

@@ -28,7 +28,7 @@ OneToN<BazelTarget, BazelTarget> ExtractAliasedBy(const ParsedProject &p) {
   for (const auto &[_, build_file] : p.ParsedFiles()) {
     query::FindTargets(
       build_file->ast, {"alias"}, [&](const query::Result &details) {
-        auto alias = BazelTarget::ParseFrom(details.name, build_file->package);
+        auto alias = build_file->package.QualifiedTarget(details.name);
         auto actual =
           BazelTarget::ParseFrom(details.actual, build_file->package);
         if (!alias.has_value() || !actual.has_value()) return;

bant/explore/dependency-graph.cc

@@ -126,7 +126,7 @@ DependencyGraph BuildDependencyGraph(Session &session,
     query::FindTargets(parsed->ast, kRulesOfInterest,  //
                        [&](const query::Result &result) {
                          auto target_or =
-                           BazelTarget::ParseFrom(result.name, current_package);
+                           current_package.QualifiedTarget(result.name);
                          if (!target_or || !pattern.Match(*target_or)) return;
                          deps_to_resolve_todo.insert(*target_or);
                        });
@@ -154,7 +154,7 @@ DependencyGraph BuildDependencyGraph(Session &session,
       if (!parsed) continue;
       query::FindTargets(
         parsed->ast, kRulesOfInterest, [&](const query::Result &result) {
-          auto target_or = BazelTarget::ParseFrom(result.name, current_package);
+          auto target_or = current_package.QualifiedTarget(result.name);
           if (!target_or.has_value()) return;
           const bool interested = (deps_to_resolve_todo.erase(*target_or) == 1);
           if (!interested) return;

bant/explore/header-providers.cc

@@ -102,7 +102,7 @@ static void IterateCCLibraryHeaders(const ParsedBuildFile &build_file,
 
   query::FindTargets(
     build_file.ast, kInterestingLibRules, [&](const query::Result &cc_lib) {
-      auto cc_library = BazelTarget::ParseFrom(cc_lib.name, build_file.package);
+      auto cc_library = build_file.package.QualifiedTarget(cc_lib.name);
       if (!cc_library.has_value()) return;
 
       auto hdrs = query::ExtractStringList(cc_lib.hdrs_list);
@@ -227,7 +227,7 @@ static void AppendProtoLibraryHeaders(const ParsedBuildFile &build_file,
   OneToOne<BazelTarget, BazelTarget> proto_lib2cc_proto_lib[2];
   query::FindTargets(
     build_file.ast, kInterestingLibRules, [&](const query::Result &cc_plib) {
-      auto target = BazelTarget::ParseFrom(cc_plib.name, build_file.package);
+      auto target = build_file.package.QualifiedTarget(cc_plib.name);
       if (!target.has_value()) return;
 
       const bool is_grpc = (cc_plib.rule == "cc_grpc_library");
@@ -251,7 +251,7 @@ static void AppendProtoLibraryHeaders(const ParsedBuildFile &build_file,
   // Putting it all together.
   query::FindTargets(
     build_file.ast, {"proto_library"}, [&](const query::Result &proto_lib) {
-      auto target = BazelTarget::ParseFrom(proto_lib.name, build_file.package);
+      auto target = build_file.package.QualifiedTarget(proto_lib.name);
       if (!target.has_value()) return;
 
       for (const bool is_grpc : {false, true}) {
@@ -324,8 +324,7 @@ ProvidedFromTarget ExtractGeneratedFromGenrule(const ParsedProject &project,
       file_content->ast, {"genrule"}, [&](const query::Result &params) {
         const auto genfiles = query::ExtractStringList(params.outs_list);
 
-        auto target =
-          BazelTarget::ParseFrom(params.name, file_content->package);
+        auto target = file_content->package.QualifiedTarget(params.name);
         if (!target.has_value()) return;
 
         for (const std::string_view generated : genfiles) {

bant/frontend/parsed-project.cc

@@ -277,7 +277,7 @@ void PrintProject(Session &session, const BazelPattern &pattern,
       file_content->ast, {}, [&](const query::Result &result) {
         std::optional<BazelTarget> maybe_target;
         if (!result.name.empty()) {
-          maybe_target = BazelTarget::ParseFrom(result.name, package);
+          maybe_target = package.QualifiedTarget(result.name);
         }
         if (!pattern.is_recursive()) {
           // If pattern requires some match, need to check now.

bant/tool/BUILD

@@ -131,6 +131,5 @@ cc_library(
         "//bant/frontend:parsed-project",
         "//bant/util:file-utils",
         "//bant/util:table-printer",
-        "@abseil-cpp//absl/strings",
     ],
 )

bant/tool/canon-targets.cc

@@ -44,7 +44,7 @@ size_t CreateCanonicalizeEdits(Session &session, const ParsedProject &project,
     const BazelPackage &current_package = parsed_package->package;
     query::FindTargets(
       parsed_package->ast, {}, [&](const query::Result &target) {
-        auto self = BazelTarget::ParseFrom(target.name, current_package);
+        auto self = current_package.QualifiedTarget(target.name);
         if (!self.has_value()) {
           return;
         }

bant/tool/compilation-db.cc

@@ -164,8 +164,7 @@ static std::vector<std::string> CollectIncDirs(const ParsedProject &project) {
       parsed_package->ast,
       {"cc_library", "cc_binary", "cc_test", "proto_library"},
       [&](const query::Result &details) {
-        auto target = BazelTarget::ParseFrom(absl::StrCat(":", details.name),
-                                             current_package);
+        auto target = current_package.QualifiedTarget(details.name);
         // If we're one of those targets that come with the own -I prefix,
         // add all these.
         const auto inc_dirs = query::ExtractStringList(details.includes_list);
@@ -302,8 +301,7 @@ static void WriteCompilationDB(Session &session, const ParsedProject &project,
     query::FindTargets(
       parsed_package->ast, {"cc_library", "cc_binary", "cc_test"},
       [&](const query::Result &details) {
-        auto target = BazelTarget::ParseFrom(absl::StrCat(":", details.name),
-                                             current_package);
+        auto target = current_package.QualifiedTarget(details.name);
         if (!target.has_value() || !pattern.Match(*target)) {
           return;
         }

bant/tool/dwyu.cc

@@ -149,8 +149,8 @@ void DWYUGenerator::InitKnownLibraries() {
                         "cc_proto_library", "grpc_cc_library",  // specialized
                         "cc_test"},  // also indexing test for testonly check.
                        [&](const query::Result &target) {
-                         auto self = BazelTarget::ParseFrom(
-                           absl::StrCat(":", target.name), current_package);
+                         auto self =
+                           current_package.QualifiedTarget(target.name);
                          if (!self.has_value()) {
                            return;
                          }
@@ -582,8 +582,7 @@ size_t DWYUGenerator::CreateEditsForPattern(const BazelPattern &pattern) {
     query::FindTargets(
       parsed_package->ast, {"cc_library", "cc_binary", "cc_test"},
       [&](const query::Result &details) {
-        auto target = BazelTarget::ParseFrom(absl::StrCat(":", details.name),
-                                             current_package);
+        auto target = current_package.QualifiedTarget(details.name);
         if (!target.has_value() || !pattern.Match(*target)) {
           return;
         }

bant/tool/workspace.cc

@@ -21,7 +21,6 @@
 #include <string_view>
 #include <vector>
 
-#include "absl/strings/str_cat.h"
 #include "bant/explore/query-utils.h"
 #include "bant/frontend/parsed-project.h"
 #include "bant/session.h"
@@ -70,8 +69,7 @@ BazelWorkspace CreateFilteredWorkspace(Session &session,
             query::ExtractStringList(details.node->argument());
         } else {
           // Classical cc_library(), cc_binary() etc that has dependencies.
-          auto target = BazelTarget::ParseFrom(absl::StrCat(":", details.name),
-                                               current_package);
+          auto target = current_package.QualifiedTarget(details.name);
           if (!target.has_value() || !pattern.Match(*target)) {
             return;
           }

bant/types-bazel.cc

@@ -37,6 +37,14 @@ std::string BazelPackage::ToString() const {
   return absl::StrCat(project, "//", path);
 }
 
+std::optional<BazelTarget> BazelPackage::QualifiedTarget(
+  std::string_view name) const {
+  if (name.empty()) return std::nullopt;
+  if (name[0] == ':') name.remove_prefix(1);
+  if (name.empty()) return std::nullopt;
+  return BazelTarget(*this, name);
+}
+
 std::string BazelPackage::QualifiedFile(std::string_view relative_file) const {
   if (relative_file.starts_with(':')) {
     relative_file.remove_prefix(1);

bant/types-bazel.h

@@ -29,6 +29,8 @@
 #include "re2/re2.h"
 
 namespace bant {
+class BazelTarget;
+
 // Something like //foo/bar or @baz//foo/bar
 struct BazelPackage {
   BazelPackage() = default;
@@ -38,6 +40,9 @@ struct BazelPackage {
   // Parse and create package if possible.
   static std::optional<BazelPackage> ParseFrom(std::string_view str);
 
+  // Given a name of a target without package, reutrn a fully qualified target.
+  std::optional<BazelTarget> QualifiedTarget(std::string_view name) const;
+
   std::string project;  // either empty, or something like @foo_bar_baz
   std::string path;     // path relative to project w/o leading/trailing '/'
 
@@ -84,6 +89,7 @@ class BazelTarget {
   bool operator!=(const BazelTarget &) const = default;
 
  private:
+  friend BazelPackage;
   // Make sure we only use the ParseFrom(). Not always needed, but this way
   // it is harder to accidentally have broken targets.
   BazelTarget(BazelPackage package, std::string_view target)