Add a UniqueVector class 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 "base/strings/string_util.h"
 #include "tools/gn/config_values_extractors.h"
@@ skipping 302 matching lines @@
   out_ << "build ";
   path_output_.WriteFile(out_, internal_output_file);
   if (external_output_file != internal_output_file) {
     out_ << " ";
     path_output_.WriteFile(out_, external_output_file);
   }
   out_ << ": "
        << helper_.GetRulePrefix(target_->settings())
        << Toolchain::ToolTypeToName(tool_type_);
 
-  std::set<OutputFile> extra_object_files;
-  std::vector<const Target*> linkable_deps;
-  std::vector<const Target*> non_linkable_deps;
+  UniqueVector<OutputFile> extra_object_files;
+  UniqueVector<const Target*> linkable_deps;
+  UniqueVector<const Target*> non_linkable_deps;
   GetDeps(&extra_object_files, &linkable_deps, &non_linkable_deps);
 
   // Object files.
   for (size_t i = 0; i < object_files.size(); i++) {
     out_ << " ";
     path_output_.WriteFile(out_, object_files[i]);
   }
-  for (std::set<OutputFile>::iterator i = extra_object_files.begin();
-       i != extra_object_files.end(); ++i) {
+  for (size_t i = 0; i < extra_object_files.size(); i++) {
     out_ << " ";
-    path_output_.WriteFile(out_, *i);
+    path_output_.WriteFile(out_, extra_object_files[i]);
   }
 
   // Libs.
   for (size_t i = 0; i < linkable_deps.size(); i++) {
     out_ << " ";
     path_output_.WriteFile(out_, helper_.GetTargetOutputFile(linkable_deps[i]));
   }
 
   // Append data dependencies as implicit dependencies.
   WriteImplicitDependencies(non_linkable_deps);
 
   out_ << std::endl;
 }
 
 void NinjaBinaryTargetWriter::WriteSourceSetStamp(
     const std::vector<OutputFile>& object_files) {
   // The stamp rule for source sets is generally not used, since targets that
   // depend on this will reference the object files directly. However, writing
   // this rule allows the user to type the name of the target and get a build
   // which can be convenient for development.
   out_ << "build ";
   path_output_.WriteFile(out_, helper_.GetTargetOutputFile(target_));
   out_ << ": "
        << helper_.GetRulePrefix(target_->settings())
        << "stamp";
 
-  std::set<OutputFile> extra_object_files;
-  std::vector<const Target*> linkable_deps;
-  std::vector<const Target*> non_linkable_deps;
+  UniqueVector<OutputFile> extra_object_files;
+  UniqueVector<const Target*> linkable_deps;
+  UniqueVector<const Target*> non_linkable_deps;
   GetDeps(&extra_object_files, &linkable_deps, &non_linkable_deps);
 
   // The classifier should never put extra object files in a source set:
   // any source sets that we depend on should appear in our non-linkable
   // deps instead.
   DCHECK(extra_object_files.empty());
 
   for (size_t i = 0; i < object_files.size(); i++) {
     out_ << " ";
     path_output_.WriteFile(out_, object_files[i]);
   }
 
   // Append data dependencies as implicit dependencies.
   WriteImplicitDependencies(non_linkable_deps);
 
   out_ << std::endl;
 }
 
 void NinjaBinaryTargetWriter::GetDeps(
-    std::set<OutputFile>* extra_object_files,
-    std::vector<const Target*>* linkable_deps,
-    std::vector<const Target*>* non_linkable_deps) const {
+    UniqueVector<OutputFile>* extra_object_files,
+    UniqueVector<const Target*>* linkable_deps,
+    UniqueVector<const Target*>* non_linkable_deps) const {
   const LabelTargetVector& deps = target_->deps();
-  const std::set<const Target*>& inherited = target_->inherited_libraries();
+  const UniqueVector<const Target*>& inherited =
+      target_->inherited_libraries();
 
   // Normal deps.
   for (size_t i = 0; i < deps.size(); i++) {
-    if (inherited.find(deps[i].ptr) != inherited.end())
-      continue;  // Don't add dupes.
     ClassifyDependency(deps[i].ptr, extra_object_files,
                        linkable_deps, non_linkable_deps);
   }
 
   // Inherited libraries.
-  for (std::set<const Target*>::const_iterator i = inherited.begin();
-       i != inherited.end(); ++i) {
-    ClassifyDependency(*i, extra_object_files,
+  for (size_t i = 0; i < inherited.size(); i++) {
+    ClassifyDependency(inherited[i], extra_object_files,
                        linkable_deps, non_linkable_deps);
   }
 
   // Data deps.
   const LabelTargetVector& datadeps = target_->datadeps();
   for (size_t i = 0; i < datadeps.size(); i++)
     non_linkable_deps->push_back(datadeps[i].ptr);
 }
 
 void NinjaBinaryTargetWriter::ClassifyDependency(
     const Target* dep,
-    std::set<OutputFile>* extra_object_files,
-    std::vector<const Target*>* linkable_deps,
-    std::vector<const Target*>* non_linkable_deps) const {
+    UniqueVector<OutputFile>* extra_object_files,
+    UniqueVector<const Target*>* linkable_deps,
+    UniqueVector<const Target*>* non_linkable_deps) const {
   // Only these types of outputs have libraries linked into them. Child deps of
   // static libraries get pushed up the dependency tree until one of these is
   // reached, and source sets don't link at all.
   bool can_link_libs =
       (target_->output_type() == Target::EXECUTABLE ||
        target_->output_type() == Target::SHARED_LIBRARY);
 
   if (dep->output_type() == Target::SOURCE_SET) {
     // Source sets have their object files linked into final targets (shared
     // libraries and executables). Intermediate static libraries and other
     // source sets just forward the dependency, otherwise the files in the
     // source set can easily get linked more than once which will cause
     // multiple definition errors.
     //
     // In the future, we may need a way to specify a "complete" static library
     // for cases where you want a static library that includes all source sets
     // (like if you're shipping that to customers to link against).
     if (target_->output_type() != Target::SOURCE_SET &&
         target_->output_type() != Target::STATIC_LIBRARY) {
       // Linking in a source set to an executable or shared library, copy its
       // object files.
       for (size_t i = 0; i < dep->sources().size(); i++) {
         SourceFileType input_file_type = GetSourceFileType(dep->sources()[i]);
         if (input_file_type != SOURCE_UNKNOWN &&
             input_file_type != SOURCE_H) {
           // Note we need to specify the target as the source_set target
           // itself, since this is used to prefix the object file name.
-          extra_object_files->insert(helper_.GetOutputFileForSource(
+          extra_object_files->push_back(helper_.GetOutputFileForSource(
               dep, dep->sources()[i], input_file_type));
         }
       }
     }
   } else if (can_link_libs && dep->IsLinkable()) {
     linkable_deps->push_back(dep);
   } else {
     non_linkable_deps->push_back(dep);
   }
 }
 
 void NinjaBinaryTargetWriter::WriteImplicitDependencies(
-    const std::vector<const Target*>& non_linkable_deps) {
+    const UniqueVector<const Target*>& non_linkable_deps) {
   const std::vector<SourceFile>& data = target_->data();
   if (!non_linkable_deps.empty() || !data.empty()) {
     out_ << " ||";
 
     // Non-linkable targets.
     for (size_t i = 0; i < non_linkable_deps.size(); i++) {
       out_ << " ";
       path_output_.WriteFile(out_,
                              helper_.GetTargetOutputFile(non_linkable_deps[i]));
     }
 
     // Data files.
     const std::vector<SourceFile>& data = target_->data();
     for (size_t i = 0; i < data.size(); i++) {
       out_ << " ";
       path_output_.WriteFile(out_, data[i]);
     }
   }
 }