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

tools/gn/functions.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/functions.h"
 
 #include <stddef.h>
 #include <iostream>
 #include <utility>
 
@@ skipping 339 matching lines @@
 
   Introduces the given arguments into the current scope. If they are not
   specified on the command line or in a toolchain's arguments, the default
   values given in the declare_args block will be used. However, these defaults
   will not override command-line values.
 
   See also "gn help buildargs" for an overview.
 
   The precise behavior of declare args is:
 
-   1. The declare_arg block executes. Any variables in the enclosing scope are
-      available for reading.
+   1. The declare_args() block executes. Any variable defined in the enclosing
+      scope is available for reading, but any variable defined earlier in
+      the current scope is not (since the overrides haven't been applied yet).
 
    2. At the end of executing the block, any variables set within that scope
       are saved globally as build arguments, with their current values being
       saved as the "default value" for that argument.
 
    3. User-defined overrides are applied. Anything set in "gn args" now
       overrides any default values. The resulting set of variables is promoted
       to be readable from the following code in the file.
 
   This has some ramifications that may not be obvious:
 
     - You should not perform difficult work inside a declare_args block since
       this only sets a default value that may be discarded. In particular,
       don't use the result of exec_script() to set the default value. If you
       want to have a script-defined default, set some default "undefined" value
       like [], "", or -1, and after the declare_args block, call exec_script if
       the value is unset by the user.
 
-    - Any code inside of the declare_args block will see the default values of
-      previous variables defined in the block rather than the user-overridden
-      value. This can be surprising because you will be used to seeing the
-      overridden value. If you need to make the default value of one arg
-      dependent on the possibly-overridden value of another, write two separate
-      declare_args blocks:
+    - Because you cannot read the value of a variable defined in the same
+      block, if you need to make the default value of one arg depend
+      on the possibly-overridden value of another, write two separate
+      declare_args() blocks:
 
         declare_args() {
           enable_foo = true
         }
         declare_args() {
           # Bar defaults to same user-overridden state as foo.
           enable_bar = enable_foo
         }
 
 Example
@@ skipping 12 matching lines @@
 Value RunDeclareArgs(Scope* scope,
                      const FunctionCallNode* function,
                      const std::vector<Value>& args,
                      BlockNode* block,
                      Err* err) {
   NonNestableBlock non_nestable(scope, function, "declare_args");
   if (!non_nestable.Enter(err))
     return Value();
 
   Scope block_scope(scope);
+
+  // Mark that this scope is part of a declare_args() call, in order to
+  // prevent reads of any variables that are defined earlier in the same call
+  // (see `gn help declare_args` for more).
+  block_scope.SetProperty(&kInDeclareArgsKey, (void *)&kInDeclareArgsKey);

[brettw, 2016/11/18 22:07:43]

Are you sure you need the void* cast here? I think any pointer should be
convertable to void*.

[Dirk Pranke, 2016/11/18 22:35:39]

I thought I didn't need it, either, but the compiler kept complaining. I will
double-check.

+
   block->Execute(&block_scope, err);
   if (err->has_error())
     return Value();
 
   // Pass the values from our scope into the Args object for adding to the
   // scope with the proper values (taking into account the defaults given in
   // the block_scope, and arguments passed into the build).
   Scope::KeyValueMap values;
   block_scope.GetCurrentScopeValues(&values);
   scope->settings()->build_settings()->build_args().DeclareArgs(
@@ skipping 679 matching lines @@
   }
 
   // Otherwise it's a no-block function.
   if (!VerifyNoBlockForFunctionCall(function, block, err))
     return Value();
   return found_function->second.no_block_runner(scope, function,
                                                 args.list_value(), err);
 }
 
 }  // namespace functions