Add forward_variables_from() and target() to GN

tools/gn/scope.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/scope.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/template.h"
@@ skipping 43 matching lines @@
       item_collector_(nullptr) {
 }
 
 Scope::~Scope() {
   STLDeleteContainerPairSecondPointers(target_defaults_.begin(),
                                        target_defaults_.end());
 }
 
 const Value* Scope::GetValue(const base::StringPiece& ident,
                              bool counts_as_used) {
-  // First check for programatically-provided values.
+  // First check for programmatically-provided values.
   for (const auto& provider : programmatic_providers_) {
     const Value* v = provider->GetProgrammaticValue(ident);
     if (v)
       return v;
   }
 
   RecordMap::iterator found = values_.find(ident);
   if (found != values_.end()) {
     if (counts_as_used)
       found->second.used = true;
     return &found->second.value;
   }
 
   // Search in the parent scope.
   if (const_containing_)
     return const_containing_->GetValue(ident);
   if (mutable_containing_)
     return mutable_containing_->GetValue(ident, counts_as_used);
   return nullptr;
 }
 
 Value* Scope::GetMutableValue(const base::StringPiece& ident,
                               bool counts_as_used) {
-  // Don't do programatic values, which are not mutable.
+  // Don't do programmatic values, which are not mutable.
   RecordMap::iterator found = values_.find(ident);
   if (found != values_.end()) {
     if (counts_as_used)
       found->second.used = true;
     return &found->second.value;
   }
 
   // Search in the parent mutable scope, but not const one.
   if (mutable_containing_)
     return mutable_containing_->GetMutableValue(ident, counts_as_used);
@@ skipping 10 matching lines @@
   if (containing()) {
     const Value* in_containing = containing()->GetValue(ident);
     if (in_containing) {
       // Promote to current scope.
       return SetValue(ident, *in_containing, set_node);
     }
   }
   return nullptr;
 }
 
+base::StringPiece Scope::GetStorageKey(const base::StringPiece& ident) const {
+  RecordMap::const_iterator found = values_.find(ident);
+  if (found != values_.end())
+    return found->first;
+
+  // Search in parent scope.
+  if (containing())
+    return containing()->GetStorageKey(ident);
+  return base::StringPiece();
+}
+
 const Value* Scope::GetValue(const base::StringPiece& ident) const {
   RecordMap::const_iterator found = values_.find(ident);
   if (found != values_.end())
     return &found->second.value;
   if (containing())
     return containing()->GetValue(ident);
   return nullptr;
 }
 
 Value* Scope::SetValue(const base::StringPiece& ident,
@@ skipping 44 matching lines @@
 
 void Scope::MarkUsed(const base::StringPiece& ident) {
   RecordMap::iterator found = values_.find(ident);
   if (found == values_.end()) {
     NOTREACHED();
     return;
   }
   found->second.used = true;
 }
 
+void Scope::MarkAllUsed() {
+  for (auto& cur : values_)
+    cur.second.used = true;
+}
+
 void Scope::MarkUnused(const base::StringPiece& ident) {
   RecordMap::iterator found = values_.find(ident);
   if (found == values_.end()) {
     NOTREACHED();
     return;
   }
   found->second.used = false;
 }
 
 bool Scope::IsSetButUnused(const base::StringPiece& ident) const {
@@ skipping 55 matching lines @@
         err->AppendSubErr(Err(pair.second.value, "defined here.",
             "Which would clobber the one in your current scope"));
         err->AppendSubErr(Err(*existing_value, "defined here.",
             "Executing " + desc_string + " should not conflict with anything "
             "in the current\nscope unless the values are identical."));
         return false;
       }
     }
     dest->values_[pair.first] = pair.second;
 
-    if (options.mark_used)
+    if (options.mark_dest_used)
       dest->MarkUsed(pair.first);
   }
 
   // Target defaults are owning pointers.
   for (const auto& pair : target_defaults_) {
     if (!options.clobber_existing) {
       if (dest->GetTargetDefaults(pair.first)) {
         // TODO(brettw) it would be nice to know the origin of a
         // set_target_defaults so we can give locations for the colliding target
         // defaults.
@@ skipping 199 matching lines @@
 }
 
 void Scope::AddProvider(ProgrammaticProvider* p) {
   programmatic_providers_.insert(p);
 }
 
 void Scope::RemoveProvider(ProgrammaticProvider* p) {
   DCHECK(programmatic_providers_.find(p) != programmatic_providers_.end());
   programmatic_providers_.erase(p);
 }