src/gn/rust_project_writer.cc - third_party/gn - Git at Google

 // Copyright 2020 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 "gn/rust_project_writer.h"

 #include <fstream>
 #include <sstream>
 #include <tuple>

 #include "base/json/string_escape.h"
 #include "gn/builder.h"
 #include "gn/deps_iterator.h"
 #include "gn/filesystem_utils.h"
 #include "gn/ninja_target_command_util.h"
 #include "gn/rust_project_writer_helpers.h"
 #include "gn/rust_tool.h"
 #include "gn/source_file.h"
 #include "gn/string_output_buffer.h"
 #include "gn/tool.h"

 #if defined(OS_WINDOWS)
 #define NEWLINE "\r\n"
 #else
 #define NEWLINE "\n"
 #endif

 // Current structure of rust-project.json output file
 //
 // {
 //    "roots": [
 //      "some/source/root"  // each crate's source root
 //    ],
 //    "crates": [
 //        {
 //            "deps": [
 //                {
 //                    "crate": 1, // index into crate array
 //                    "name": "alloc" // extern name of dependency
 //                },
 //            ],
 //            "edition": "2018", // edition of crate
 //            "cfg": [
 //              "unix", // "atomic" value config options
 //              "rust_panic=\"abort\""", // key="value" config options
 //            ]
 //            "root_module": "absolute path to crate"
 //        },
 // }
 //

 bool RustProjectWriter::RunAndWriteFiles(const BuildSettings* build_settings,
                                          const Builder& builder,
                                          const std::string& file_name,
                                          bool quiet,
                                          Err* err) {
   SourceFile output_file = build_settings->build_dir().ResolveRelativeFile(
       Value(nullptr, file_name), err);
   if (output_file.is_null())
     return false;

   base::FilePath output_path = build_settings->GetFullPath(output_file);

   std::vector<const Target*> all_targets = builder.GetAllResolvedTargets();

   StringOutputBuffer out_buffer;
   std::ostream out(&out_buffer);

   RenderJSON(build_settings, all_targets, out);

   if (out_buffer.ContentsEqual(output_path)) {
     return true;
   }

   return out_buffer.WriteToFile(output_path, err);
 }

 // Map of Targets to their index in the crates list (for linking dependencies to
 // their indexes).
 using TargetIndexMap = std::unordered_map<const Target*, uint32_t>;

 // A collection of Targets.
 using TargetsVector = UniqueVector<const Target*>;

 // Get the Rust deps for a target, recursively expanding OutputType::GROUPS
 // that are present in the GN structure.  This will return a flattened list of
 // deps from the groups, but will not expand a Rust lib dependency to find any
 // transitive Rust dependencies.
 void GetRustDeps(const Target* target, TargetsVector* rust_deps) {
   for (const auto& pair : target->GetDeps(Target::DEPS_LINKED)) {
     const Target* dep = pair.ptr;

     if (dep->source_types_used().RustSourceUsed()) {
       // Include any Rust dep.
       rust_deps->push_back(dep);
     } else if (dep->output_type() == Target::OutputType::GROUP) {
       // Inspect (recursively) any group to see if it contains Rust deps.
       GetRustDeps(dep, rust_deps);
     }
   }
 }
 TargetsVector GetRustDeps(const Target* target) {
   TargetsVector deps;
   GetRustDeps(target, &deps);
   return deps;
 }

 // TODO(bwb) Parse sysroot structure from toml files. This is fragile and might
 // break if upstream changes the dependency structure.
 const std::string_view sysroot_crates[] = {"std",
                                            "core",
                                            "alloc",
                                            "collections",
                                            "libc",
                                            "panic_unwind",
                                            "proc_macro",
                                            "rustc_unicode",
                                            "std_unicode",
                                            "test",
                                            "alloc_jemalloc",
                                            "alloc_system",
                                            "compiler_builtins",
                                            "getopts",
                                            "panic_abort",
                                            "unwind",
                                            "build_helper",
                                            "rustc_asan",
                                            "rustc_lsan",
                                            "rustc_msan",
                                            "rustc_tsan",
                                            "syntax"};

 // Multiple sysroot crates have dependenices on each other.  This provides a
 // mechanism for specifiying that in an extendible manner.
 const std::unordered_map<std::string_view, std::vector<std::string_view>>
     sysroot_deps_map = {{"alloc", {"core"}},
                         {"std", {"alloc", "core", "panic_abort", "unwind"}}};

 // Add each of the crates a sysroot has, including their dependencies.
 void AddSysrootCrate(const BuildSettings* build_settings,
                      const std::string_view crate,
                      const std::string_view current_sysroot,
                      SysrootCrateIndexMap& sysroot_crate_lookup,
                      CrateList& crate_list) {
   if (sysroot_crate_lookup.find(crate) != sysroot_crate_lookup.end()) {
     // If this sysroot crate is already in the lookup, we don't add it again.
     return;
   }

   // Add any crates that this sysroot crate depends on.
   auto deps_lookup = sysroot_deps_map.find(crate);
   if (deps_lookup != sysroot_deps_map.end()) {
     auto deps = (*deps_lookup).second;
     for (auto dep : deps) {
       AddSysrootCrate(build_settings, dep, current_sysroot,
                       sysroot_crate_lookup, crate_list);
     }
   }

   size_t crate_index = crate_list.size();
   sysroot_crate_lookup.insert(std::make_pair(crate, crate_index));

   base::FilePath rebased_out_dir =
       build_settings->GetFullPath(build_settings->build_dir());
   auto crate_path =
       FilePathToUTF8(rebased_out_dir) + std::string(current_sysroot) +
       "/lib/rustlib/src/rust/src/lib" + std::string(crate) + "/lib.rs";

   Crate sysroot_crate =
       Crate(SourceFile(crate_path), crate_index, std::string(crate), "2018");

   sysroot_crate.AddConfigItem("debug_assertions");

   if (deps_lookup != sysroot_deps_map.end()) {
     auto deps = (*deps_lookup).second;
     for (auto dep : deps) {
       auto idx = sysroot_crate_lookup[dep];
       sysroot_crate.AddDependency(idx, std::string(dep));
     }
   }

   crate_list.push_back(sysroot_crate);
 }

 // Add the given sysroot to the project, if it hasn't already been added.
 void AddSysroot(const BuildSettings* build_settings,
                 const std::string_view sysroot,
                 SysrootIndexMap& sysroot_lookup,
                 CrateList& crate_list) {
   // If this sysroot is already in the lookup, we don't add it again.
   if (sysroot_lookup.find(sysroot) != sysroot_lookup.end()) {
     return;
   }

   // Otherwise, add all of its crates
   for (auto crate : sysroot_crates) {
     AddSysrootCrate(build_settings, crate, sysroot, sysroot_lookup[sysroot],
                     crate_list);
   }
 }

 void AddTarget(const BuildSettings* build_settings,
                const Target* target,
                TargetIndexMap& lookup,
                SysrootIndexMap& sysroot_lookup,
                CrateList& crate_list) {
   if (lookup.find(target) != lookup.end()) {
     // If target is already in the lookup, we don't add it again.
     return;
   }

   // Check what sysroot this target needs.  Add it to the crate list if it
   // hasn't already been added.
   auto rust_tool =
       target->toolchain()->GetToolForSourceTypeAsRust(SourceFile::SOURCE_RS);
   auto current_sysroot = rust_tool->GetSysroot();
   if (current_sysroot != "" && sysroot_lookup.count(current_sysroot) == 0) {
     AddSysroot(build_settings, current_sysroot, sysroot_lookup, crate_list);
   }

   auto crate_deps = GetRustDeps(target);

   // Add all dependencies of this crate, before this crate.
   for (const auto& dep : crate_deps) {
     AddTarget(build_settings, dep, lookup, sysroot_lookup, crate_list);
   }

   // The index of a crate is its position (0-based) in the list of crates.
   size_t crate_id = crate_list.size();

   // Add the target to the crate lookup.
   lookup.insert(std::make_pair(target, crate_id));

   SourceFile crate_root = target->rust_values().crate_root();
   std::string crate_label = target->label().GetUserVisibleName(false);

   std::string cfg_prefix("--cfg=");
   std::string edition_prefix("--edition=");
   ConfigList cfgs;

   std::string edition = "2015";  // default to be overridden as needed

   for (ConfigValuesIterator iter(target); !iter.done(); iter.Next()) {
     for (const auto& flag : iter.cur().rustflags()) {
       // extract the edition of this target
       if (!flag.compare(0, edition_prefix.size(), edition_prefix)) {
         edition = flag.substr(edition_prefix.size());
       }
       if (!flag.compare(0, cfg_prefix.size(), cfg_prefix)) {
         auto cfg = flag.substr(cfg_prefix.size());
         std::string escaped_config;
         base::EscapeJSONString(cfg, false, &escaped_config);
         cfgs.push_back(escaped_config);
       }
     }
   }

   Crate crate = Crate(crate_root, crate_id, crate_label, edition);

   crate.AddConfigItem("test");
   crate.AddConfigItem("debug_assertions");

   for (auto& cfg : cfgs) {
     crate.AddConfigItem(cfg);
   }

   // Add the sysroot dependency, if there is one.
   if (current_sysroot != "") {
     // TODO(bwb) If this library doesn't depend on std, use core instead
     auto std_idx = sysroot_lookup[current_sysroot].find("std");
     if (std_idx != sysroot_lookup[current_sysroot].end()) {
       crate.AddDependency(std_idx->second, "std");
     }
   }

   // Add the rest of the crate dependencies.
   for (const auto& dep : crate_deps) {
     auto idx = lookup[dep];
     crate.AddDependency(idx, dep->rust_values().crate_name());
   }

   crate_list.push_back(crate);
 }

 void WriteCrates(const BuildSettings* build_settings,
                  CrateList& crate_list,
                  std::ostream& rust_project) {
   rust_project << "{" NEWLINE;
   rust_project << "  \"roots\": [";
   bool first_root = true;
   for (auto& crate : crate_list) {
     if (!first_root)
       rust_project << ",";
     first_root = false;

     std::string root_dir =
         FilePathToUTF8(build_settings->GetFullPath(crate.root().GetDir()));
     rust_project << NEWLINE "    \"" << root_dir << "\"";
   }
   rust_project << NEWLINE "  ]," NEWLINE;
   rust_project << "  \"crates\": [";
   bool first_crate = true;
   for (auto& crate : crate_list) {
     if (!first_crate)
       rust_project << ",";
     first_crate = false;

     auto crate_root = FilePathToUTF8(build_settings->GetFullPath(crate.root()));

     rust_project << NEWLINE << "    {" NEWLINE
                  << "      \"crate_id\": " << crate.index() << "," NEWLINE
                  << "      \"root_module\": \"" << crate_root << "\"," NEWLINE
                  << "      \"label\": \"" << crate.label() << "\"," NEWLINE
                  << "      \"deps\": [";

     bool first_dep = true;
     for (auto& dep : crate.dependencies()) {
       if (!first_dep)
         rust_project << ",";
       first_dep = false;

       rust_project << NEWLINE << "        {" NEWLINE
                    << "          \"crate\": " << dep.first << "," NEWLINE
                    << "          \"name\": \"" << dep.second << "\"" NEWLINE
                    << "        }";
     }
     rust_project << NEWLINE "      ]," NEWLINE;  // end dep list

     rust_project << "      \"edition\": \"" << crate.edition() << "\"," NEWLINE;

     rust_project << "      \"cfg\": [";
     bool first_cfg = true;
     for (const auto& cfg : crate.configs()) {
       if (!first_cfg)
         rust_project << ",";
       first_cfg = false;

       rust_project << NEWLINE;
       rust_project << "        \"" << cfg << "\"";
     }
     rust_project << NEWLINE;
     rust_project << "      ]" NEWLINE;  // end cfgs

     rust_project << "    }";  // end crate
   }
   rust_project << NEWLINE "  ]" NEWLINE;  // end crate list
   rust_project << "}" NEWLINE;
 }

 void RustProjectWriter::RenderJSON(const BuildSettings* build_settings,
                                    std::vector<const Target*>& all_targets,
                                    std::ostream& rust_project) {
   TargetIndexMap lookup;
   SysrootIndexMap sysroot_lookup;
   CrateList crate_list;

   // All the crates defined in the project.
   for (const auto* target : all_targets) {
     if (!target->IsBinary() || !target->source_types_used().RustSourceUsed())
       continue;

     AddTarget(build_settings, target, lookup, sysroot_lookup, crate_list);
   }

   WriteCrates(build_settings, crate_list, rust_project);
 }
	// Copyright 2020 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 "gn/rust_project_writer.h"

	#include <fstream>
	#include <sstream>
	#include <tuple>

	#include "base/json/string_escape.h"
	#include "gn/builder.h"
	#include "gn/deps_iterator.h"
	#include "gn/filesystem_utils.h"
	#include "gn/ninja_target_command_util.h"
	#include "gn/rust_project_writer_helpers.h"
	#include "gn/rust_tool.h"
	#include "gn/source_file.h"
	#include "gn/string_output_buffer.h"
	#include "gn/tool.h"

	#if defined(OS_WINDOWS)
	#define NEWLINE "\r\n"
	#else
	#define NEWLINE "\n"
	#endif

	// Current structure of rust-project.json output file
	//
	// {
	// "roots": [
	// "some/source/root" // each crate's source root
	// ],
	// "crates": [
	// {
	// "deps": [
	// {
	// "crate": 1, // index into crate array
	// "name": "alloc" // extern name of dependency
	// },
	// ],
	// "edition": "2018", // edition of crate
	// "cfg": [
	// "unix", // "atomic" value config options
	// "rust_panic=\"abort\""", // key="value" config options
	// ]
	// "root_module": "absolute path to crate"
	// },
	// }
	//

	bool RustProjectWriter::RunAndWriteFiles(const BuildSettings* build_settings,
	const Builder& builder,
	const std::string& file_name,
	bool quiet,
	Err* err) {
	SourceFile output_file = build_settings->build_dir().ResolveRelativeFile(
	Value(nullptr, file_name), err);
	if (output_file.is_null())
	return false;

	base::FilePath output_path = build_settings->GetFullPath(output_file);

	std::vector<const Target*> all_targets = builder.GetAllResolvedTargets();

	StringOutputBuffer out_buffer;
	std::ostream out(&out_buffer);

	RenderJSON(build_settings, all_targets, out);

	if (out_buffer.ContentsEqual(output_path)) {
	return true;
	}

	return out_buffer.WriteToFile(output_path, err);
	}

	// Map of Targets to their index in the crates list (for linking dependencies to
	// their indexes).
	using TargetIndexMap = std::unordered_map<const Target*, uint32_t>;

	// A collection of Targets.
	using TargetsVector = UniqueVector<const Target*>;

	// Get the Rust deps for a target, recursively expanding OutputType::GROUPS
	// that are present in the GN structure. This will return a flattened list of
	// deps from the groups, but will not expand a Rust lib dependency to find any
	// transitive Rust dependencies.
	void GetRustDeps(const Target* target, TargetsVector* rust_deps) {
	for (const auto& pair : target->GetDeps(Target::DEPS_LINKED)) {
	const Target* dep = pair.ptr;

	if (dep->source_types_used().RustSourceUsed()) {
	// Include any Rust dep.
	rust_deps->push_back(dep);
	} else if (dep->output_type() == Target::OutputType::GROUP) {
	// Inspect (recursively) any group to see if it contains Rust deps.
	GetRustDeps(dep, rust_deps);
	}
	}
	}
	TargetsVector GetRustDeps(const Target* target) {
	TargetsVector deps;
	GetRustDeps(target, &deps);
	return deps;
	}

	// TODO(bwb) Parse sysroot structure from toml files. This is fragile and might
	// break if upstream changes the dependency structure.
	const std::string_view sysroot_crates[] = {"std",
	"core",
	"alloc",
	"collections",
	"libc",
	"panic_unwind",
	"proc_macro",
	"rustc_unicode",
	"std_unicode",
	"test",
	"alloc_jemalloc",
	"alloc_system",
	"compiler_builtins",
	"getopts",
	"panic_abort",
	"unwind",
	"build_helper",
	"rustc_asan",
	"rustc_lsan",
	"rustc_msan",
	"rustc_tsan",
	"syntax"};

	// Multiple sysroot crates have dependenices on each other. This provides a
	// mechanism for specifiying that in an extendible manner.
	const std::unordered_map<std::string_view, std::vector<std::string_view>>
	sysroot_deps_map = {{"alloc", {"core"}},
	{"std", {"alloc", "core", "panic_abort", "unwind"}}};

	// Add each of the crates a sysroot has, including their dependencies.
	void AddSysrootCrate(const BuildSettings* build_settings,
	const std::string_view crate,
	const std::string_view current_sysroot,
	SysrootCrateIndexMap& sysroot_crate_lookup,
	CrateList& crate_list) {
	if (sysroot_crate_lookup.find(crate) != sysroot_crate_lookup.end()) {
	// If this sysroot crate is already in the lookup, we don't add it again.
	return;
	}

	// Add any crates that this sysroot crate depends on.
	auto deps_lookup = sysroot_deps_map.find(crate);
	if (deps_lookup != sysroot_deps_map.end()) {
	auto deps = (*deps_lookup).second;
	for (auto dep : deps) {
	AddSysrootCrate(build_settings, dep, current_sysroot,
	sysroot_crate_lookup, crate_list);
	}
	}

	size_t crate_index = crate_list.size();
	sysroot_crate_lookup.insert(std::make_pair(crate, crate_index));

	base::FilePath rebased_out_dir =
	build_settings->GetFullPath(build_settings->build_dir());
	auto crate_path =
	FilePathToUTF8(rebased_out_dir) + std::string(current_sysroot) +
	"/lib/rustlib/src/rust/src/lib" + std::string(crate) + "/lib.rs";

	Crate sysroot_crate =
	Crate(SourceFile(crate_path), crate_index, std::string(crate), "2018");

	sysroot_crate.AddConfigItem("debug_assertions");

	if (deps_lookup != sysroot_deps_map.end()) {
	auto deps = (*deps_lookup).second;
	for (auto dep : deps) {
	auto idx = sysroot_crate_lookup[dep];
	sysroot_crate.AddDependency(idx, std::string(dep));
	}
	}

	crate_list.push_back(sysroot_crate);
	}

	// Add the given sysroot to the project, if it hasn't already been added.
	void AddSysroot(const BuildSettings* build_settings,
	const std::string_view sysroot,
	SysrootIndexMap& sysroot_lookup,
	CrateList& crate_list) {
	// If this sysroot is already in the lookup, we don't add it again.
	if (sysroot_lookup.find(sysroot) != sysroot_lookup.end()) {
	return;
	}

	// Otherwise, add all of its crates
	for (auto crate : sysroot_crates) {
	AddSysrootCrate(build_settings, crate, sysroot, sysroot_lookup[sysroot],
	crate_list);
	}
	}

	void AddTarget(const BuildSettings* build_settings,
	const Target* target,
	TargetIndexMap& lookup,
	SysrootIndexMap& sysroot_lookup,
	CrateList& crate_list) {
	if (lookup.find(target) != lookup.end()) {
	// If target is already in the lookup, we don't add it again.
	return;
	}

	// Check what sysroot this target needs. Add it to the crate list if it
	// hasn't already been added.
	auto rust_tool =
	target->toolchain()->GetToolForSourceTypeAsRust(SourceFile::SOURCE_RS);
	auto current_sysroot = rust_tool->GetSysroot();
	if (current_sysroot != "" && sysroot_lookup.count(current_sysroot) == 0) {
	AddSysroot(build_settings, current_sysroot, sysroot_lookup, crate_list);
	}

	auto crate_deps = GetRustDeps(target);

	// Add all dependencies of this crate, before this crate.
	for (const auto& dep : crate_deps) {
	AddTarget(build_settings, dep, lookup, sysroot_lookup, crate_list);
	}

	// The index of a crate is its position (0-based) in the list of crates.
	size_t crate_id = crate_list.size();

	// Add the target to the crate lookup.
	lookup.insert(std::make_pair(target, crate_id));

	SourceFile crate_root = target->rust_values().crate_root();
	std::string crate_label = target->label().GetUserVisibleName(false);

	std::string cfg_prefix("--cfg=");
	std::string edition_prefix("--edition=");
	ConfigList cfgs;

	std::string edition = "2015"; // default to be overridden as needed

	for (ConfigValuesIterator iter(target); !iter.done(); iter.Next()) {
	for (const auto& flag : iter.cur().rustflags()) {
	// extract the edition of this target
	if (!flag.compare(0, edition_prefix.size(), edition_prefix)) {
	edition = flag.substr(edition_prefix.size());
	}
	if (!flag.compare(0, cfg_prefix.size(), cfg_prefix)) {
	auto cfg = flag.substr(cfg_prefix.size());
	std::string escaped_config;
	base::EscapeJSONString(cfg, false, &escaped_config);
	cfgs.push_back(escaped_config);
	}
	}
	}

	Crate crate = Crate(crate_root, crate_id, crate_label, edition);

	crate.AddConfigItem("test");
	crate.AddConfigItem("debug_assertions");

	for (auto& cfg : cfgs) {
	crate.AddConfigItem(cfg);
	}

	// Add the sysroot dependency, if there is one.
	if (current_sysroot != "") {
	// TODO(bwb) If this library doesn't depend on std, use core instead
	auto std_idx = sysroot_lookup[current_sysroot].find("std");
	if (std_idx != sysroot_lookup[current_sysroot].end()) {
	crate.AddDependency(std_idx->second, "std");
	}
	}

	// Add the rest of the crate dependencies.
	for (const auto& dep : crate_deps) {
	auto idx = lookup[dep];
	crate.AddDependency(idx, dep->rust_values().crate_name());
	}

	crate_list.push_back(crate);
	}

	void WriteCrates(const BuildSettings* build_settings,
	CrateList& crate_list,
	std::ostream& rust_project) {
	rust_project << "{" NEWLINE;
	rust_project << " \"roots\": [";
	bool first_root = true;
	for (auto& crate : crate_list) {
	if (!first_root)
	rust_project << ",";
	first_root = false;

	std::string root_dir =
	FilePathToUTF8(build_settings->GetFullPath(crate.root().GetDir()));
	rust_project << NEWLINE " \"" << root_dir << "\"";
	}
	rust_project << NEWLINE " ]," NEWLINE;
	rust_project << " \"crates\": [";
	bool first_crate = true;
	for (auto& crate : crate_list) {
	if (!first_crate)
	rust_project << ",";
	first_crate = false;

	auto crate_root = FilePathToUTF8(build_settings->GetFullPath(crate.root()));

	rust_project << NEWLINE << " {" NEWLINE
	<< " \"crate_id\": " << crate.index() << "," NEWLINE
	<< " \"root_module\": \"" << crate_root << "\"," NEWLINE
	<< " \"label\": \"" << crate.label() << "\"," NEWLINE
	<< " \"deps\": [";

	bool first_dep = true;
	for (auto& dep : crate.dependencies()) {
	if (!first_dep)
	rust_project << ",";
	first_dep = false;

	rust_project << NEWLINE << " {" NEWLINE
	<< " \"crate\": " << dep.first << "," NEWLINE
	<< " \"name\": \"" << dep.second << "\"" NEWLINE
	<< " }";
	}
	rust_project << NEWLINE " ]," NEWLINE; // end dep list

	rust_project << " \"edition\": \"" << crate.edition() << "\"," NEWLINE;

	rust_project << " \"cfg\": [";
	bool first_cfg = true;
	for (const auto& cfg : crate.configs()) {
	if (!first_cfg)
	rust_project << ",";
	first_cfg = false;

	rust_project << NEWLINE;
	rust_project << " \"" << cfg << "\"";
	}
	rust_project << NEWLINE;
	rust_project << " ]" NEWLINE; // end cfgs

	rust_project << " }"; // end crate
	}
	rust_project << NEWLINE " ]" NEWLINE; // end crate list
	rust_project << "}" NEWLINE;
	}

	void RustProjectWriter::RenderJSON(const BuildSettings* build_settings,
	std::vector<const Target*>& all_targets,
	std::ostream& rust_project) {
	TargetIndexMap lookup;
	SysrootIndexMap sysroot_lookup;
	CrateList crate_list;

	// All the crates defined in the project.
	for (const auto* target : all_targets) {
	if (!target->IsBinary() \|\| !target->source_types_used().RustSourceUsed())
	continue;

	AddTarget(build_settings, target, lookup, sysroot_lookup, crate_list);
	}

	WriteCrates(build_settings, crate_list, rust_project);
	}