GN: Add notion of 'complete' static libraries, akin to GYP.

tools/gn/target.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/target.h"
 
 #include "base/bind.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "tools/gn/config_values_extractors.h"
@@ skipping 55 matching lines @@
   return deps.size();
 }
 
 }  // namespace
 
 Target::Target(const Settings* settings, const Label& label)
     : Item(settings, label),
       output_type_(UNKNOWN),
       all_headers_public_(true),
       check_includes_(true),
+      complete_static_lib_(false),
       testonly_(false),
       hard_dep_(false),
       toolchain_(NULL) {
 }
 
 Target::~Target() {
 }
 
 // static
 const char* Target::GetStringForOutputType(OutputType type) {
@@ skipping 67 matching lines @@
   if (!CheckTestonly(err))
     return false;
 
   return true;
 }
 
 bool Target::IsLinkable() const {
   return output_type_ == STATIC_LIBRARY || output_type_ == SHARED_LIBRARY;
 }
 
+bool Target::IsFinal() const {
+  return output_type_ == EXECUTABLE || output_type_ == SHARED_LIBRARY ||
+         (output_type_ == STATIC_LIBRARY && complete_static_lib_);
+}
+
 std::string Target::GetComputedOutputName(bool include_prefix) const {
   DCHECK(toolchain_)
       << "Toolchain must be specified before getting the computed output name.";
 
   const std::string& name = output_name_.empty() ? label().name()
                                                  : output_name_;
 
   std::string result;
   if (include_prefix) {
     const Tool* tool = toolchain_->GetToolForTargetFinalOutput(this);
@@ skipping 55 matching lines @@
     MergeDirectDependentConfigsFrom(dep, &configs_);
 
     // Direct dependent libraries.
     if (dep->output_type() == STATIC_LIBRARY ||
         dep->output_type() == SHARED_LIBRARY ||
         dep->output_type() == SOURCE_SET)
       inherited_libraries_.push_back(dep);
 
     // Inherited libraries and flags are inherited across static library
     // boundaries.
     if (dep->output_type() != SHARED_LIBRARY &&

[brettw, 2014/09/12 20:53:33]

I think this condition should be replaced by an IsFinal call. And we should add
a test for this.

This happens when you have

exe -> static lib A (complete) -> static lib or source set B

B should be linked into A which will then be linked into the exe. Without this,
I think there will be a copy of B's code in A, and B itself will also be added
to the inherited libraries of the exe.

See the Target.InheritLibs test.

[Chris Masone, 2014/09/12 22:56:37]

Done.

         dep->output_type() != EXECUTABLE) {
       inherited_libraries_.Append(dep->inherited_libraries().begin(),
                                   dep->inherited_libraries().end());
 
       // Inherited library settings.
       all_lib_dirs_.append(dep->all_lib_dirs());
       all_libs_.append(dep->all_libs());
     }
   }
 }
@@ skipping 132 matching lines @@
 
   for (size_t i = 0; i < datadeps_.size(); i++) {
     if (datadeps_[i].ptr->testonly()) {
       *err = MakeTestOnlyError(this, datadeps_[i].ptr);
       return false;
     }
   }
 
   return true;
 }