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

tools/gn/parse_tree.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/parse_tree.h"
 
 #include <stdint.h>
 
 #include <string>
 #include <tuple>
@@ skipping 469 matching lines @@
 }
 
 IdentifierNode::~IdentifierNode() {
 }
 
 const IdentifierNode* IdentifierNode::AsIdentifier() const {
   return this;
 }
 
 Value IdentifierNode::Execute(Scope* scope, Err* err) const {
-  const Value* value = scope->GetValue(value_.value(), true);
+  const Scope *found_in_scope = nullptr;

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

Put the * next to the type like you do for Value below (GN code should be
consistent in this regard).

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

ack.

+  const Value* value = scope->GetValueWithScope(value_.value(), true,
+                                                &found_in_scope);
   Value result;
   if (!value) {
     *err = MakeErrorDescribing("Undefined identifier");
     return result;
   }
 
+  // Check that the scope that contains the defined value and the

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

I think it would be easier to follow if this was in a helper function
EnsureNotReadingFromDeclareArgs or something. This function can be in
functions.cc so you don't need to have a global declare_args key (I like to keep
these keys narrowly scoped).

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

Acknowledged.

+  // current scope are not part of the same declare_args() block, in
+  // order to prevent reading a value that might be overridden later.
+  const Scope *found_args_scope = nullptr;
+  if (found_in_scope)
+    found_in_scope->GetProperty(&kInDeclareArgsKey, &found_args_scope);
+
+  const Scope* cur_args_scope = nullptr;
+  scope->GetProperty(&kInDeclareArgsKey, &cur_args_scope);
+  if (found_args_scope && cur_args_scope &&
+      (found_args_scope == cur_args_scope)) {
+    *err = MakeErrorDescribing(
+      "Reading a variable defined in the same declare_args() call.");
+    return result;
+  }
+
   result = *value;
   result.set_origin(this);
   return result;
 }
 
 LocationRange IdentifierNode::GetRange() const {
   return value_.range();
 }
 
 Err IdentifierNode::MakeErrorDescribing(const std::string& msg,
@@ skipping 360 matching lines @@
 
 Err EndNode::MakeErrorDescribing(const std::string& msg,
                                         const std::string& help) const {
   return Err(value_, msg, help);
 }
 
 void EndNode::Print(std::ostream& out, int indent) const {
   out << IndentFor(indent) << "END(" << value_.value() << ")\n";
   PrintComments(out, indent);
 }