Use $root:default as a "default" rule

tools/gn/ninja_build_writer.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "tools/gn/ninja_build_writer.h"
 
 #include <stddef.h>
 
 #include <fstream>
 #include <map>
@@ skipping 331 matching lines @@
 }
 
 const char kNinjaRules_Help[] =
     R"(Ninja build rules
 
 The "all" and "default" rules
 
   All generated targets (see "gn help execution") will be added to an implicit
   build rule called "all" so "ninja all" will always compile everything. The
   default rule will be used by Ninja if no specific target is specified (just
-  typing "ninja"). If there is a target named "//:default" it will be the
-  default build rule, otherwise the implicit "all" rule will be used.
+  typing "ninja"). If there is a target named "default" in the root build file,
+  it will be the default build rule, otherwise the implicit "all" rule will be
+  used.
 
 Phony rules
 
   GN generates Ninja "phony" rules for targets in the default toolchain.  The
   phony rules can collide with each other and with the names of generated files
   so are generated with the following priority:
 
     1. Actual files generated by the build always take precedence.
 
     2. Targets in the toplevel //BUILD.gn file.
@@ skipping 25 matching lines @@
 )";
 
 bool NinjaBuildWriter::WritePhonyAndAllRules(Err* err) {
   // Track rules as we generate them so we don't accidentally write a phony
   // rule that collides with something else.
   // GN internally generates an "all" target, so don't duplicate it.
   base::hash_set<std::string> written_rules;
   written_rules.insert("all");
 
   // Set if we encounter a target named "//:default".
-  bool default_target_exists = false;
+  const Target* default_target = nullptr;
 
   // Targets in the root build file.
   std::vector<const Target*> toplevel_targets;
 
   // Targets with names matching their toplevel directories. For example
   // "//foo:foo". Expect this is the naming scheme for "big components."
   std::vector<const Target*> toplevel_dir_targets;
 
   // Tracks the number of each target with the given short name, as well
   // as the short names of executables (which will be a subset of short_names).
   std::map<std::string, Counts> short_names;
   std::map<std::string, Counts> exes;
 
   // ----------------------------------------------------
   // If you change this algorithm, update the help above!
   // ----------------------------------------------------
 
   for (const Target* target : default_toolchain_targets_) {
     const Label& label = target->label();
     const std::string& short_name = label.name();
 
-    if (label.dir().value() == "//" && label.name() == "default")
-      default_target_exists = true;
+    if (label.dir() == build_settings_->root_target_label().dir() &&
+        short_name == "default")
+      default_target = target;
 
     // Count the number of targets with the given short name.
     Counts& short_names_counts = short_names[short_name];
     short_names_counts.count++;
     short_names_counts.last_seen = target;
 
     // Count executables with the given short name.
     if (target->output_type() == Target::EXECUTABLE) {
       Counts& exes_counts = exes[short_name];
       exes_counts.count++;
@@ skipping 97 matching lines @@
 
     EscapeOptions ninja_escape;
     ninja_escape.mode = ESCAPE_NINJA;
     for (const Target* target : default_toolchain_targets_) {
       out_ << " $\n    ";
       path_output_.WriteFile(out_, target->dependency_output_file());
     }
   }
   out_ << std::endl;
 
-  if (default_target_exists)
-    out_ << "\ndefault default" << std::endl;
-  else if (!default_toolchain_targets_.empty())
+  if (default_target) {
+    // Use the short name when available
+    if (written_rules.find("default") != written_rules.end()) {
+      out_ << "\ndefault default" << std::endl;
+    } else {
+      out_ << "\ndefault ";
+      path_output_.WriteFile(out_, default_target->dependency_output_file());
+      out_ << std::endl;
+    }
+  } else if (!default_toolchain_targets_.empty()) {
     out_ << "\ndefault all" << std::endl;
+  }
 
   return true;
 }
 
 void NinjaBuildWriter::WritePhonyRule(const Target* target,
                                       const std::string& phony_name) {
   EscapeOptions ninja_escape;
   ninja_escape.mode = ESCAPE_NINJA;
 
   // Escape for special chars Ninja will handle.
   std::string escaped = EscapeString(phony_name, ninja_escape, nullptr);
 
   out_ << "build " << escaped << ": phony ";
   path_output_.WriteFile(out_, target->dependency_output_file());
   out_ << std::endl;
 }