Allow creation and modification of scopes in 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/memory/ptr_util.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/template.h"
@@ skipping 48 matching lines @@
     : const_containing_(parent),
       mutable_containing_(nullptr),
       settings_(parent->settings()),
       mode_flags_(0),
       item_collector_(nullptr) {
 }
 
 Scope::~Scope() {
 }
 
+void Scope::DetachFromContaining() {
+  const_containing_ = nullptr;
+  mutable_containing_ = nullptr;
+}
+
 const Value* Scope::GetValue(const base::StringPiece& ident,
                              bool counts_as_used) {
   // First check for programmatically-provided values.
   for (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,
+                              SearchNested search_mode,
                               bool counts_as_used) {
   // 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);
-  return nullptr;
-}
-
-Value* Scope::GetValueForcedToCurrentScope(const base::StringPiece& ident,
-                                           const ParseNode* set_node) {
-  RecordMap::iterator found = values_.find(ident);
-  if (found != values_.end())
-    return &found->second.value;  // Already have in the current scope.
-
-  // Search in the parent scope.
-  if (containing()) {
-    const Value* in_containing = containing()->GetValue(ident);
-    if (in_containing) {
-      // Promote to current scope.
-      return SetValue(ident, *in_containing, set_node);
-    }
+  // Search in the parent mutable scope if requested, but not const one.
+  if (search_mode == SEARCH_NESTED && mutable_containing_) {
+    return mutable_containing_->GetMutableValue(
+        ident, Scope::SEARCH_NESTED, counts_as_used);
   }
   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,
-                       const Value& v,
+                       Value v,
                        const ParseNode* set_node) {
   Record& r = values_[ident];  // Clears any existing value.
-  r.value = v;
+  r.value = std::move(v);
   r.value.set_origin(set_node);
   return &r.value;
 }
 
 void Scope::RemoveIdentifier(const base::StringPiece& ident) {
   RecordMap::iterator found = values_.find(ident);
   if (found != values_.end())
     values_.erase(found);
 }
 
@@ skipping 362 matching lines @@
     return false;
   for (const auto& pair : a) {
     const auto& found_b = b.find(pair.first);
     if (found_b == b.end())
       return false;  // Item in 'a' but not 'b'.
     if (pair.second.value != found_b->second.value)
       return false;  // Values for variable in 'a' and 'b' are different.
   }
   return true;
 }