Support for source_target_relative expansion in GN

tools/gn/substitution_writer.h

 // 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.
 
 #ifndef TOOLS_GN_SUBSTITUTION_WRITER_H_
 #define TOOLS_GN_SUBSTITUTION_WRITER_H_
 
 #include <iosfwd>
 #include <vector>
 
@@ skipping 27 matching lines @@
 //
 //  - Compiler substitutions: These are used to compute compiler outputs.
 //    It includes all source substitutions (since they depend on the various
 //    parts of the source file) as well as the target substitutions.
 //
 //  - Linker substitutions: These are used to compute linker outputs. It
 //    includes the target substitutions.
 //
 // The compiler and linker specific substitutions do NOT include the various
 // cflags, ldflags, libraries, etc. These are written by the ninja target
 // writer since they depend on traversing the dependency tree.

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

Can you append a note here that the functions that take a target can accept a
null target pointer if there is no target context, and then the substitutions
requiring target context won't work.

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

Done.

 class SubstitutionWriter {
  public:
   enum OutputStyle {
     OUTPUT_ABSOLUTE,  // Dirs will be absolute "//foo/bar".
     OUTPUT_RELATIVE,  // Dirs will be relative to a given directory.
   };
 
   // Writes the pattern to the given stream with no special handling, and with
   // Ninja variables replacing the patterns.
   static void WriteWithNinjaVariables(
@@ skipping 14 matching lines @@
       const Settings* settings,
       const SubstitutionList& list,
       std::vector<OutputFile>* output);
 
   // Source substitutions -----------------------------------------------------
 
   // Applies the substitution pattern to a source file, returning the result
   // as either a string, a SourceFile or an OutputFile. If the result is
   // expected to be a SourceFile or an OutputFile, this will CHECK if the
   // result isn't in the correct directory. The caller should validate this
   // first (see for example IsFileInOuputDir).

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

GN almost never supports random pointers being null, so I think it's worthwhile
to call out that target can be null really obviously. In each of these blocks
with comments above the function, can you append "The target can be null (see
class comment above)."

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

Done.

   static SourceFile ApplyPatternToSource(
+      const Target* target,
       const Settings* settings,
       const SubstitutionPattern& pattern,
       const SourceFile& source);
   static std::string ApplyPatternToSourceAsString(
+      const Target* target,
       const Settings* settings,
       const SubstitutionPattern& pattern,
       const SourceFile& source);
   static OutputFile ApplyPatternToSourceAsOutputFile(
+      const Target* target,
       const Settings* settings,
       const SubstitutionPattern& pattern,
       const SourceFile& source);
 
   // Applies the substitution list to a source, APPENDING the result to the
   // given output vector. It works this way so one can call multiple times to
   // apply to multiple files and create a list. The result can either be
   // SourceFiles or OutputFiles.
   static void ApplyListToSource(
+      const Target* target,
       const Settings* settings,
       const SubstitutionList& list,
       const SourceFile& source,
       std::vector<SourceFile>* output);
   static void ApplyListToSourceAsString(
+      const Target* target,
       const Settings* settings,
       const SubstitutionList& list,
       const SourceFile& source,
       std::vector<std::string>* output);
   static void ApplyListToSourceAsOutputFile(
+      const Target* target,
       const Settings* settings,
       const SubstitutionList& list,
       const SourceFile& source,
       std::vector<OutputFile>* output);
 
   // Like ApplyListToSource but applies the list to all sources and replaces
   // rather than appends the output (this produces the complete output).
   static void ApplyListToSources(
+      const Target* target,
       const Settings* settings,
       const SubstitutionList& list,
       const std::vector<SourceFile>& sources,
       std::vector<SourceFile>* output);
   static void ApplyListToSourcesAsString(
+      const Target* target,
       const Settings* settings,
       const SubstitutionList& list,
       const std::vector<SourceFile>& sources,
       std::vector<std::string>* output);
   static void ApplyListToSourcesAsOutputFile(
+      const Target* target,
       const Settings* settings,
       const SubstitutionList& list,
       const std::vector<SourceFile>& sources,
       std::vector<OutputFile>* output);
 
   // Given a list of source replacement types used, writes the Ninja variable
   // definitions for the given source file to use for those replacements. The
   // variables will be indented two spaces. Since this is for writing to
   // Ninja files, paths will be relative to the build dir, and no definition
   // for {{source}} will be written since that maps to Ninja's implicit $in
   // variable.
   static void WriteNinjaVariablesForSource(
+      const Target* target,
       const Settings* settings,
       const SourceFile& source,
       const std::vector<SubstitutionType>& types,
       const EscapeOptions& escape_options,
       std::ostream& out);
 
   // Extracts the given type of substitution related to a source file from the
   // given source file. If output_style is OUTPUT_RELATIVE, relative_to
   // indicates the directory that the relative directories should be relative
   // to, otherwise it is ignored.
   static std::string GetSourceSubstitution(
+      const Target* target,
       const Settings* settings,
       const SourceFile& source,
       SubstitutionType type,
       OutputStyle output_style,
       const SourceDir& relative_to);
 
   // Target substitutions ------------------------------------------------------
   //
   // Handles the target substitutions that apply to both compiler and linker
   // tools.
@@ skipping 57 matching lines @@
   // Like GetSourceSubstitution but for strings based on the target or
   // toolchain. This type of result will always be relative to the build
   // directory.
   static std::string GetLinkerSubstitution(
       const Target* target,
       const Tool* tool,
       SubstitutionType type);
 };
 
 #endif  // TOOLS_GN_SUBSTITUTION_WRITER_H_