Add support for module-definition files to gn

tools/gn/ninja_binary_target_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_binary_target_writer.h"
 
 #include <set>
 #include <sstream>
 
 #include "base/strings/string_util.h"
@@ skipping 62 matching lines @@
       tool_(target->toolchain()->GetToolForTargetFinalOutput(target)) {
 }
 
 NinjaBinaryTargetWriter::~NinjaBinaryTargetWriter() {
 }
 
 void NinjaBinaryTargetWriter::Run() {
   WriteCompilerVars();
 
   std::vector<OutputFile> obj_files;
-  WriteSources(&obj_files);
+  std::vector<SourceFile> other_files;
+  WriteSources(&obj_files, &other_files);
 
   if (target_->output_type() == Target::SOURCE_SET)
     WriteSourceSetStamp(obj_files);
   else
-    WriteLinkerStuff(obj_files);
+    WriteLinkerStuff(obj_files, other_files);
 }
 
 void NinjaBinaryTargetWriter::WriteCompilerVars() {
   const SubstitutionBits& subst = target_->toolchain()->substitution_bits();
 
   // Defines.
   if (subst.used[SUBSTITUTION_DEFINES]) {
     out_ << kSubstitutionNinjaNames[SUBSTITUTION_DEFINES] << " =";
     RecursiveTargetConfigToStream<std::string>(
         target_, &ConfigValues::defines, DefineWriter(), out_);
@@ skipping 28 matching lines @@
   WRITE_FLAGS(cflags_cc, SUBSTITUTION_CFLAGS_CC)
   WRITE_FLAGS(cflags_objc, SUBSTITUTION_CFLAGS_OBJC)
   WRITE_FLAGS(cflags_objcc, SUBSTITUTION_CFLAGS_OBJCC)
 
 #undef WRITE_FLAGS
 
   WriteSharedVars(subst);
 }
 
 void NinjaBinaryTargetWriter::WriteSources(
-    std::vector<OutputFile>* object_files) {
+    std::vector<OutputFile>* object_files,
+    std::vector<SourceFile>* other_files) {
   object_files->reserve(target_->sources().size());
 
   OutputFile input_dep =
       WriteInputDepsStampAndGetDep(std::vector<const Target*>());
 
   std::string rule_prefix = GetNinjaRulePrefixForToolchain(settings_);
 
   std::vector<OutputFile> tool_outputs;  // Prevent reallocation in loop.
   for (const auto& source : target_->sources()) {
     Toolchain::ToolType tool_type = Toolchain::TYPE_NONE;
-    if (!GetOutputFilesForSource(target_, source,
-                                 &tool_type, &tool_outputs))
+    if (!GetOutputFilesForSource(target_, source, &tool_type, &tool_outputs)) {
+      if (GetSourceFileType(source) == SOURCE_DEF)
+        other_files->push_back(source);
       continue;  // No output for this source.
+    }
 
     if (tool_type != Toolchain::TYPE_NONE) {
       out_ << "build";
       path_output_.WriteFiles(out_, tool_outputs);
 
       out_ << ": " << rule_prefix << Toolchain::ToolTypeToName(tool_type);
       out_ << " ";
       path_output_.WriteFile(out_, source);
       if (!input_dep.value().empty()) {
         // Write out the input dependencies as an order-only dependency. This
@@ skipping 27 matching lines @@
     }
 
     // It's theoretically possible for a compiler to produce more than one
     // output, but we'll only link to the first output.
     object_files->push_back(tool_outputs[0]);
   }
   out_ << std::endl;
 }
 
 void NinjaBinaryTargetWriter::WriteLinkerStuff(
-    const std::vector<OutputFile>& object_files) {
+    const std::vector<OutputFile>& object_files,
+    const std::vector<SourceFile>& other_files) {
   std::vector<OutputFile> output_files;
   SubstitutionWriter::ApplyListToLinkerAsOutputFile(
       target_, tool_, tool_->outputs(), &output_files);
 
   out_ << "build";
   path_output_.WriteFiles(out_, output_files);
 
   out_ << ": "
        << GetNinjaRulePrefixForToolchain(settings_)
        << Toolchain::ToolTypeToName(
@@ skipping 29 matching lines @@
       // later.
       implicit_deps.push_back(cur->dependency_output_file());
       solibs.push_back(cur->link_output_file());
     } else {
       // Normal case, just link to this target.
       out_ << " ";
       path_output_.WriteFile(out_, cur->link_output_file());
     }
   }
 
+  const SourceFile* optional_def_file = nullptr;
+  if (!other_files.empty()) {
+    for (const SourceFile& src_file : other_files) {
+      if (GetSourceFileType(src_file) == SOURCE_DEF) {
+        optional_def_file = &src_file;
+        implicit_deps.push_back(
+            OutputFile(settings_->build_settings(), src_file));
+        break;  // Only one def file is allowed.
+      }
+    }
+  }
+
   // Append implicit dependencies collected above.
   if (!implicit_deps.empty()) {
     out_ << " |";
     path_output_.WriteFiles(out_, implicit_deps);
   }
 
   // Append data dependencies as order-only dependencies.
   //
   // This will include data dependencies and input dependencies (like when
   // this target depends on an action). Having the data dependencies in this
   // list ensures that the data is available at runtime when the user builds
   // this target.
   //
   // The action dependencies are not strictly necessary in this case. They
   // should also have been collected via the input deps stamp that each source
   // file has for an order-only dependency, and since this target depends on
   // the sources, there is already an implicit order-only dependency. However,
   // it's extra work to separate these out and there's no disadvantage to
   // listing them again.
   WriteOrderOnlyDependencies(non_linkable_deps);
 
   // End of the link "build" line.
   out_ << std::endl;
 
   // These go in the inner scope of the link line.
-  WriteLinkerFlags();
+  WriteLinkerFlags(optional_def_file);
+
   WriteLibs();
   WriteOutputExtension();
   WriteSolibs(solibs);
 }
 
-void NinjaBinaryTargetWriter::WriteLinkerFlags() {
+void NinjaBinaryTargetWriter::WriteLinkerFlags(
+    const SourceFile* optional_def_file) {
   out_ << "  ldflags =";
 
   // First the ldflags from the target and its config.
   EscapeOptions flag_options = GetFlagOptions();
   RecursiveTargetConfigStringsToStream(target_, &ConfigValues::ldflags,
                                        flag_options, out_);
 
   // Followed by library search paths that have been recursively pushed
   // through the dependency tree.
   const OrderedSet<SourceDir> all_lib_dirs = target_->all_lib_dirs();
   if (!all_lib_dirs.empty()) {
     // Since we're passing these on the command line to the linker and not
     // to Ninja, we need to do shell escaping.
     PathOutput lib_path_output(path_output_.current_dir(),
                                settings_->build_settings()->root_path_utf8(),
                                ESCAPE_NINJA_COMMAND);
     for (size_t i = 0; i < all_lib_dirs.size(); i++) {
       out_ << " " << tool_->lib_dir_switch();
       lib_path_output.WriteDir(out_, all_lib_dirs[i],
                                PathOutput::DIR_NO_LAST_SLASH);
     }
   }
+
+  if (optional_def_file) {
+    out_ << " /DEF:";
+    path_output_.WriteFile(out_, *optional_def_file);
+  }
+
   out_ << std::endl;
 }
 
 void NinjaBinaryTargetWriter::WriteLibs() {
   out_ << "  libs =";
 
   // Libraries that have been recursively pushed through the dependency tree.
   EscapeOptions lib_escape_opts;
   lib_escape_opts.mode = ESCAPE_NINJA_COMMAND;
   const OrderedSet<std::string> all_libs = target_->all_libs();
@@ skipping 166 matching lines @@
     return false;  // No tool for this file (it's a header file or something).
   const Tool* tool = target->toolchain()->GetTool(*computed_tool_type);
   if (!tool)
     return false;  // Tool does not apply for this toolchain.file.
 
   // Figure out what output(s) this compiler produces.
   SubstitutionWriter::ApplyListToCompilerAsOutputFile(
       target, source, tool->outputs(), outputs);
   return !outputs->empty();
 }