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

tools/gn/functions.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_FUNCTIONS_H_
 #define TOOLS_GN_FUNCTIONS_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 398 matching lines @@
 Value RunFunction(Scope* scope,
                   const FunctionCallNode* function,
                   const ListNode* args_list,
                   BlockNode* block,  // Optional.
                   Err* err);
 
 }  // namespace functions
 
 // Helper functions -----------------------------------------------------------
 
+// Validates that the scope that a value is defined in is not the scope
+// of the current declare_args() call, if that's what we're in. It is
+// illegal to read a value from inside the same declare_args() call, since
+// the overrides will not have been applied yet (see `gn help declare_args`
+// for more).
+bool EnsureNotReadingFromSameDeclareArgs(const ParseNode* node,
+                                         const Scope* cur_scope,
+                                         const Scope* val_scope,
+                                         Err* err);
+
 // Verifies that the current scope is not processing an import. If it is, it
 // will set the error, blame the given parse node for it, and return false.
 bool EnsureNotProcessingImport(const ParseNode* node,
                                const Scope* scope,
                                Err* err);
 
 // Like EnsureNotProcessingImport but checks for running the build config.
 bool EnsureNotProcessingBuildConfig(const ParseNode* node,
                                     const Scope* scope,
                                     Err* err);
@@ skipping 28 matching lines @@
 
 // Returns the name of the toolchain for the given scope.
 const Label& ToolchainLabelForScope(const Scope* scope);
 
 // Generates a label for the given scope, using the current directory and
 // toolchain, and the given name.
 Label MakeLabelForScope(const Scope* scope,
                         const FunctionCallNode* function,
                         const std::string& name);
 
-// Some tyesp of blocks can't be nested inside other ones. For such cases,
+// Some types of blocks can't be nested inside other ones. For such cases,
 // instantiate this object upon entering the block and Enter() will fail if
 // there is already another non-nestable block on the stack.
 class NonNestableBlock {
  public:
   // type_description is a string that will be used in error messages
   // describing the type of the block, for example, "template" or "config".
   NonNestableBlock(Scope* scope,
                    const FunctionCallNode* function,
                    const char* type_description);
   ~NonNestableBlock();
 
   bool Enter(Err* err);
 
  private:
   // Used as a void* key for the Scope to track our property. The actual value
   // is never used.
   static const int kKey;
 
   Scope* scope_;
   const FunctionCallNode* function_;
   const char* type_description_;
 
   // Set to true when the key is added to the scope so we don't try to
   // delete nonexistant keys which will cause assertions.
   bool key_added_;
 };
 
 #endif  // TOOLS_GN_FUNCTIONS_H_