Support for source_target_relative expansion in GN

tools/gn/substitution_writer.cc

 // Copyright 2014 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/substitution_writer.h"
 
 #include "tools/gn/build_settings.h"
 #include "tools/gn/escape.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/output_file.h"
@@ skipping 87 matching lines @@
     "      than the BUILD.gn file.\n"
     "        \"//foo/bar/baz.txt\" => \"gen/foo/bar\"\n"
     "\n"
     "  {{source_out_dir}}\n"
     "      The object file directory (*) corresponding to the source file's\n"
     "      path, relative to the build directory. this us be different than\n"
     "      the target's out directory if the source file is in a different\n"
     "      directory than the build.gn file.\n"
     "        \"//foo/bar/baz.txt\" => \"obj/foo/bar\"\n"
     "\n"
+    "  {{source_target_relative}}\n"
+    "      The path to the source file relative to the target's directory.\n"
+    "      This will generally be used for replicating the source directory\n"
+    "      layout in the output directory.\n"
+    "        \"//foo/bar/baz.txt\" => \"baz.txt\"\n"

[brettw, 2016/10/05 19:47:50]

Can this comment mention this only works in actions, and it's an error o use in
process_file_template (where there is no "target").

[Petr Hosek, 2016/10/11 00:59:49]

Done.

+    "\n"
     "(*) Note on directories\n"
     "\n"
     "  Paths containing directories (except the source_root_relative_dir)\n"
     "  will be different depending on what context the expansion is evaluated\n"
     "  in. Generally it should \"just work\" but it means you can't\n"
     "  concatenate strings containing these values with reasonable results.\n"
     "\n"
     "  Details: source expansions can be used in the \"outputs\" variable,\n"
     "  the \"args\" variable, and in calls to \"process_file_template\". The\n"
     "  \"args\" are passed to a script which is run from the build directory,\n"
@@ skipping 78 matching lines @@
     const SubstitutionList& list,
     std::vector<OutputFile>* output) {
   std::vector<SourceFile> output_as_sources;
   GetListAsSourceFiles(list, &output_as_sources);
   for (const auto& file : output_as_sources)
     output->push_back(OutputFile(settings->build_settings(), file));
 }
 
 // static
 SourceFile SubstitutionWriter::ApplyPatternToSource(
+      const Target* target,
       const Settings* settings,
       const SubstitutionPattern& pattern,
       const SourceFile& source) {
   std::string result_value = ApplyPatternToSourceAsString(
-      settings, pattern, source);
+      target, settings, pattern, source);
   CHECK(!result_value.empty() && result_value[0] == '/')
       << "The result of the pattern \""
       << pattern.AsString()
       << "\" was not a path beginning in \"/\" or \"//\".";
   return SourceFile(SourceFile::SWAP_IN, &result_value);
 }
 
 // static
 std::string SubstitutionWriter::ApplyPatternToSourceAsString(
+    const Target* target,
     const Settings* settings,
     const SubstitutionPattern& pattern,
     const SourceFile& source) {
   std::string result_value;
   for (const auto& subrange : pattern.ranges()) {
     if (subrange.type == SUBSTITUTION_LITERAL) {
       result_value.append(subrange.literal);
     } else {
       result_value.append(
-          GetSourceSubstitution(settings, source, subrange.type,
+          GetSourceSubstitution(target, settings, source, subrange.type,
                                 OUTPUT_ABSOLUTE, SourceDir()));
     }
   }
   return result_value;
 }
 
 // static
 OutputFile SubstitutionWriter::ApplyPatternToSourceAsOutputFile(
+    const Target* target,
     const Settings* settings,
     const SubstitutionPattern& pattern,
     const SourceFile& source) {
-  SourceFile result_as_source = ApplyPatternToSource(settings, pattern, source);
+  SourceFile result_as_source = ApplyPatternToSource(
+      target, settings, pattern, source);
   return OutputFile(settings->build_settings(), result_as_source);
 }
 
 // static
 void SubstitutionWriter::ApplyListToSource(
+    const Target* target,
     const Settings* settings,
     const SubstitutionList& list,
     const SourceFile& source,
     std::vector<SourceFile>* output) {
   for (const auto& item : list.list())
-    output->push_back(ApplyPatternToSource(settings, item, source));
+    output->push_back(ApplyPatternToSource(target, settings, item, source));
 }
 
 // static
 void SubstitutionWriter::ApplyListToSourceAsString(
+    const Target* target,
     const Settings* settings,
     const SubstitutionList& list,
     const SourceFile& source,
     std::vector<std::string>* output) {
   for (const auto& item : list.list())
-    output->push_back(ApplyPatternToSourceAsString(settings, item, source));
+    output->push_back(ApplyPatternToSourceAsString(
+        target, settings, item, source));
 }
 
 // static
 void SubstitutionWriter::ApplyListToSourceAsOutputFile(
+    const Target* target,
     const Settings* settings,
     const SubstitutionList& list,
     const SourceFile& source,
     std::vector<OutputFile>* output) {
   for (const auto& item : list.list())
-    output->push_back(ApplyPatternToSourceAsOutputFile(settings, item, source));
+    output->push_back(ApplyPatternToSourceAsOutputFile(
+        target, settings, item, source));
 }
 
 // static
 void SubstitutionWriter::ApplyListToSources(
+    const Target* target,
     const Settings* settings,
     const SubstitutionList& list,
     const std::vector<SourceFile>& sources,
     std::vector<SourceFile>* output) {
   output->clear();
   for (const auto& source : sources)
-    ApplyListToSource(settings, list, source, output);
+    ApplyListToSource(target, settings, list, source, output);
 }
 
 // static
 void SubstitutionWriter::ApplyListToSourcesAsString(
+    const Target* target,
     const Settings* settings,
     const SubstitutionList& list,
     const std::vector<SourceFile>& sources,
     std::vector<std::string>* output) {
   output->clear();
   for (const auto& source : sources)
-    ApplyListToSourceAsString(settings, list, source, output);
+    ApplyListToSourceAsString(target, settings, list, source, output);
 }
 
 // static
 void SubstitutionWriter::ApplyListToSourcesAsOutputFile(
+    const Target* target,
     const Settings* settings,
     const SubstitutionList& list,
     const std::vector<SourceFile>& sources,
     std::vector<OutputFile>* output) {
   output->clear();
   for (const auto& source : sources)
-    ApplyListToSourceAsOutputFile(settings, list, source, output);
+    ApplyListToSourceAsOutputFile(target, settings, list, source, output);
 }
 
 // static
 void SubstitutionWriter::WriteNinjaVariablesForSource(
+    const Target* target,
     const Settings* settings,
     const SourceFile& source,
     const std::vector<SubstitutionType>& types,
     const EscapeOptions& escape_options,
     std::ostream& out) {
   for (const auto& type : types) {
     // Don't write SOURCE since that just maps to Ninja's $in variable, which
     // is implicit in the rule. RESPONSE_FILE_NAME is written separately
     // only when writing target rules since it can never be used in any
     // other context (like process_file_template).
     if (type != SUBSTITUTION_SOURCE && type != SUBSTITUTION_RSP_FILE_NAME) {
       out << "  " << kSubstitutionNinjaNames[type] << " = ";
         EscapeStringToStream(
             out,
-            GetSourceSubstitution(settings, source, type, OUTPUT_RELATIVE,
+            GetSourceSubstitution(target, settings, source, type,
+                                  OUTPUT_RELATIVE,
                                   settings->build_settings()->build_dir()),
             escape_options);
       out << std::endl;
     }
   }
 }
 
 // static
 std::string SubstitutionWriter::GetSourceSubstitution(
+    const Target* target,
     const Settings* settings,
     const SourceFile& source,
     SubstitutionType type,
     OutputStyle output_style,
     const SourceDir& relative_to) {
   std::string to_rebase;
   switch (type) {
     case SUBSTITUTION_SOURCE:
       if (source.is_system_absolute())
         return source.value();
@@ skipping 22 matching lines @@
     case SUBSTITUTION_SOURCE_GEN_DIR:
       to_rebase = DirectoryWithNoLastSlash(GetSubBuildDirAsSourceDir(
           BuildDirContext(settings), source.GetDir(), BuildDirType::GEN));
       break;
 
     case SUBSTITUTION_SOURCE_OUT_DIR:
       to_rebase = DirectoryWithNoLastSlash(GetSubBuildDirAsSourceDir(
           BuildDirContext(settings), source.GetDir(), BuildDirType::OBJ));
       break;
 
+    case SUBSTITUTION_SOURCE_TARGET_RELATIVE:
+      if (target)

[brettw, 2016/10/05 19:47:50]

Chrome-style says this condition needs {}

[Petr Hosek, 2016/10/11 00:59:49]

Done.

+        return RebasePath(source.value(), target->label().dir(),
+            settings->build_settings()->root_path_utf8());
+      to_rebase = source.value();

[brettw, 2016/10/05 19:47:50]

In the "else" case here, I think it would be better to return
"_UNSUPPORTED_SUBSTITUTION_" or something so it's obvious if somebody encounters
this that they messed up, rather than the paths just being wonky.

[Petr Hosek, 2016/10/11 00:59:49]

Done.

+      break;
+
     default:
       NOTREACHED()
           << "Unsupported substitution for this function: "
           << kSubstitutionNames[type];
       return std::string();
   }
 
   // If we get here, the result is a path that should be made relative or
   // absolute according to the output_style. Other cases (just file name or
   // extension extraction) will have been handled via early return above.
@@ skipping 116 matching lines @@
     const Target* target,
     const SourceFile& source,
     SubstitutionType type) {
   // First try the common tool ones.
   std::string result;
   if (GetTargetSubstitution(target, type, &result))
     return result;
 
   // Fall-through to the source ones.
   return GetSourceSubstitution(
-      target->settings(), source, type, OUTPUT_RELATIVE,
+      target, target->settings(), source, type, OUTPUT_RELATIVE,
       target->settings()->build_settings()->build_dir());
 }
 
 // static
 OutputFile SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(
     const Target* target,
     const Tool* tool,
     const SubstitutionPattern& pattern) {
   OutputFile result;
   for (const auto& subrange : pattern.ranges()) {
@@ skipping 53 matching lines @@
         return tool->default_output_extension();
       if (target->output_extension().empty())
         return std::string();  // Explicitly set to no extension.
       return std::string(".") + target->output_extension();
 
     default:
       NOTREACHED();
       return std::string();
   }
 }