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

tools/gn/scope.h

 // 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.
 
 #ifndef TOOLS_GN_SCOPE_H_
 #define TOOLS_GN_SCOPE_H_
 
 #include <map>
 #include <memory>
 #include <set>
@@ skipping 94 matching lines @@
   explicit Scope(const Settings* settings);
 
   // Creates a dependent scope.
   explicit Scope(Scope* parent);
   explicit Scope(const Scope* parent);
 
   ~Scope();
 
   const Settings* settings() const { return settings_; }
 
-  // See the const_/mutable_containing_ var declaraions below. Yes, it's a
+  // See the const_/mutable_containing_ var declarations below. Yes, it's a
   // bit weird that we can have a const pointer to the "mutable" one.
   Scope* mutable_containing() { return mutable_containing_; }
   const Scope* mutable_containing() const { return mutable_containing_; }
   const Scope* const_containing() const { return const_containing_; }
   const Scope* containing() const {
     return mutable_containing_ ? mutable_containing_ : const_containing_;
   }
 
   // Clears any references to containing scopes. This scope will now be
   // self-sufficient.
   void DetachFromContaining();
 
   // Returns true if the scope has any values set. This does not check other
   // things that may be set like templates or defaults.
   //
   // Currently this does not search nested scopes and this will assert if you
   // want to search nested scopes. The enum is passed so the callers are
   // unambiguous about nested scope handling. This can be added if needed.
   bool HasValues(SearchNested search_nested) const;
 
   // Returns NULL if there's no such value.
   //
   // counts_as_used should be set if the variable is being read in a way that
   // should count for unused variable checking.
+  //
+  // found_in_scope is set to the scope that contains the definition of the
+  // ident. If the value was provided programmatically (like host_cpu),
+  // found_in_scope will be set to null.
   const Value* GetValue(const base::StringPiece& ident,
                         bool counts_as_used);
   const Value* GetValue(const base::StringPiece& ident) const;
+  const Value* GetValueWithScope(const base::StringPiece& ident,
+                                 const Scope** found_in_scope) const;
+  const Value* GetValueWithScope(const base::StringPiece& ident,
+                                 bool counts_as_used,
+                                 const Scope** found_in_scope);
 
   // Returns the requested value as a mutable one if possible. If the value
   // is not found in a mutable scope, then returns null. Note that the value
   // could still exist in a const scope, so GetValue() could still return
   // non-null in this case.
   //
   // Say you have a local scope that then refers to the const root scope from
   // the master build config. You can't change the values from the master
   // build config (it's read-only so it can be read from multiple threads
   // without locking). Read-only operations would work on values from the root
@@ skipping 216 matching lines @@
 
   typedef std::set<ProgrammaticProvider*> ProviderSet;
   ProviderSet programmatic_providers_;
 
   SourceDir source_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(Scope);
 };
 
 #endif  // TOOLS_GN_SCOPE_H_