Change GN to disallow reading args defined in the same declare_args() call.

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"
 
+const int kInDeclareArgsKey = 0;
+
 namespace {
 
 // FLags set in the mode_flags_ of a scope. If a bit is set, it applies
 // recursively to all dependent scopes.
 const unsigned kProcessingBuildConfigFlag = 1;
 const unsigned kProcessingImportFlag = 2;
 
 // Returns true if this variable name should be considered private. Private
 // values start with an underscore, and are not imported from "gni" files
 // when processing an import.
@@ skipping 49 matching lines @@
   mutable_containing_ = nullptr;
 }
 
 bool Scope::HasValues(SearchNested search_nested) const {
   DCHECK(search_nested == SEARCH_CURRENT);
   return !values_.empty();
 }
 
 const Value* Scope::GetValue(const base::StringPiece& ident,
                              bool counts_as_used) {
+  const Scope* found_in_scope = nullptr;
+  return GetValueWithScope(ident, counts_as_used, &found_in_scope);
+}
+
+const Value* Scope::GetValueWithScope(const base::StringPiece& ident,
+                                      bool counts_as_used,
+                                      const Scope** found_in_scope) {
   // First check for programmatically-provided values.
   for (auto* provider : programmatic_providers_) {
     const Value* v = provider->GetProgrammaticValue(ident);
-    if (v)
+    if (v) {
+      *found_in_scope = nullptr;
       return v;
+    }
   }
 
   RecordMap::iterator found = values_.find(ident);
   if (found != values_.end()) {
     if (counts_as_used)
       found->second.used = true;
+    *found_in_scope = this;
     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 const_containing_->GetValueWithScope(ident, found_in_scope);
+  if (mutable_containing_) {
+    return mutable_containing_->GetValueWithScope(ident, counts_as_used,
+                                                  found_in_scope);
+  }
   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)
@@ skipping 14 matching lines @@
   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 {
+  const Scope *found_in_scope = nullptr;
+  return GetValueWithScope(ident, &found_in_scope);
+}
+
+const Value* Scope::GetValueWithScope(const base::StringPiece& ident,
+                                      const Scope** found_in_scope) const {
   RecordMap::const_iterator found = values_.find(ident);
-  if (found != values_.end())
+  if (found != values_.end()) {
+    *found_in_scope = this;
     return &found->second.value;
+  }
   if (containing())
-    return containing()->GetValue(ident);
+    return containing()->GetValueWithScope(ident, found_in_scope);
   return nullptr;
 }
 
 Value* Scope::SetValue(const base::StringPiece& ident,
                        Value v,
                        const ParseNode* set_node) {
   Record& r = values_[ident];  // Clears any existing value.
   r.value = std::move(v);
   r.value.set_origin(set_node);
   return &r.value;
@@ skipping 370 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;
 }