Allow creation and modification of scopes in GN.

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 154 matching lines @@
   out << IndentFor(indent) << "ACCESSOR\n";
   PrintComments(out, indent);
   out << IndentFor(indent + 1) << base_.value() << "\n";
   if (index_)
     index_->Print(out, indent + 1);
   else if (member_)
     member_->Print(out, indent + 1);
 }
 
 Value AccessorNode::ExecuteArrayAccess(Scope* scope, Err* err) const {
-  Value index_value = index_->Execute(scope, err);
-  if (err->has_error())
-    return Value();
-  if (!index_value.VerifyTypeIs(Value::INTEGER, err))
-    return Value();
-
   const Value* base_value = scope->GetValue(base_.value(), true);
   if (!base_value) {
     *err = MakeErrorDescribing("Undefined identifier.");
     return Value();
   }
   if (!base_value->VerifyTypeIs(Value::LIST, err))
     return Value();
 
-  int64_t index_int = index_value.int_value();
-  if (index_int < 0) {
-    *err = Err(index_->GetRange(), "Negative array subscript.",
-        "You gave me " + base::Int64ToString(index_int) + ".");
+  size_t index = 0;
+  if (!ComputeAndValidateListIndex(scope, base_value->list_value().size(),
+                                   &index, err))
     return Value();
-  }
-  size_t index_sizet = static_cast<size_t>(index_int);
-  if (index_sizet >= base_value->list_value().size()) {
-    *err =
-        Err(index_->GetRange(), "Array subscript out of range.",
-            "You gave me " + base::Int64ToString(index_int) +
-                " but I was expecting something from 0 to " +
-                base::Int64ToString(
-                    static_cast<int64_t>(base_value->list_value().size()) - 1) +
-                ", inclusive.");
-    return Value();
-  }
-
-  // Doing this assumes that there's no way in the language to do anything
-  // between the time the reference is created and the time that the reference
-  // is used. If there is, this will crash! Currently, this is just used for
-  // array accesses where this "shouldn't" happen.
-  return base_value->list_value()[index_sizet];
+  return base_value->list_value()[index];
 }
 
 Value AccessorNode::ExecuteScopeAccess(Scope* scope, Err* err) const {
   // We jump through some hoops here since ideally a.b will count "b" as
   // accessed in the given scope. The value "a" might be in some normal nested
   // scope and we can modify it, but it might also be inherited from the
   // readonly root scope and we can't do used variable tracking on it. (It's
   // not legal to const cast it away since the root scope will be in readonly
   // mode and being accessed from multiple threads without locking.) So this
   // code handles both cases.
   const Value* result = nullptr;
 
   // Look up the value in the scope named by "base_".
-  Value* mutable_base_value = scope->GetMutableValue(base_.value(), true);
+  Value* mutable_base_value = scope->GetMutableValue(
+      base_.value(), Scope::SEARCH_NESTED, true);
   if (mutable_base_value) {
     // Common case: base value is mutable so we can track variable accesses
     // for unused value warnings.
     if (!mutable_base_value->VerifyTypeIs(Value::SCOPE, err))
       return Value();
     result = mutable_base_value->scope_value()->GetValue(
         member_->value().value(), true);
   } else {
     // Fall back to see if the value is on a read-only scope.
     const Value* const_base_value = scope->GetValue(base_.value(), true);
@@ skipping 16 matching lines @@
   }
   return *result;
 }
 
 void AccessorNode::SetNewLocation(int line_number) {
   Location old = base_.location();
   base_.set_location(
       Location(old.file(), line_number, old.column_number(), old.byte()));
 }
 
+bool AccessorNode::ComputeAndValidateListIndex(Scope* scope,
+                                               size_t max_len,
+                                               size_t* computed_index,
+                                               Err* err) const {
+  Value index_value = index_->Execute(scope, err);
+  if (err->has_error())
+    return false;
+  if (!index_value.VerifyTypeIs(Value::INTEGER, err))
+    return false;
+
+  int64_t index_int = index_value.int_value();
+  if (index_int < 0) {
+    *err = Err(index_->GetRange(), "Negative array subscript.",
+        "You gave me " + base::Int64ToString(index_int) + ".");
+    return false;
+  }
+  size_t index_sizet = static_cast<size_t>(index_int);
+  if (index_sizet >= max_len) {
+    *err = Err(index_->GetRange(), "Array subscript out of range.",
+        "You gave me " + base::Int64ToString(index_int) +
+        " but I was expecting something from 0 to " +
+        base::SizeTToString(max_len) + ", inclusive.");
+    return false;
+  }
+
+  *computed_index = index_sizet;
+  return true;
+}
+
 // BinaryOpNode ---------------------------------------------------------------
 
 BinaryOpNode::BinaryOpNode() {
 }
 
 BinaryOpNode::~BinaryOpNode() {
 }
 
 const BinaryOpNode* BinaryOpNode::AsBinaryOp() const {
   return this;
@@ skipping 14 matching lines @@
 
 void BinaryOpNode::Print(std::ostream& out, int indent) const {
   out << IndentFor(indent) << "BINARY(" << op_.value() << ")\n";
   PrintComments(out, indent);
   left_->Print(out, indent + 1);
   right_->Print(out, indent + 1);
 }
 
 // BlockNode ------------------------------------------------------------------
 
-BlockNode::BlockNode() {
+BlockNode::BlockNode(ResultMode result_mode) : result_mode_(result_mode) {
 }
 
 BlockNode::~BlockNode() {
 }
 
 const BlockNode* BlockNode::AsBlock() const {
   return this;
 }
 
-Value BlockNode::Execute(Scope* scope, Err* err) const {
+Value BlockNode::Execute(Scope* enclosing_scope, Err* err) const {
+  std::unique_ptr<Scope> nested_scope;  // May be null.
+
+  Scope* execution_scope;  // Either the enclosing_scope or nested_scope.
+  if (result_mode_ == RETURNS_SCOPE) {
+    // Create a nested scope to save the values for returning.
+    nested_scope.reset(new Scope(enclosing_scope));
+    execution_scope = nested_scope.get();
+  } else {
+    // Use the enclosing scope. Modifications will go into this also (for
+    // example, if conditions and loops).
+    execution_scope = enclosing_scope;
+  }
+
   for (size_t i = 0; i < statements_.size() && !err->has_error(); i++) {
     // Check for trying to execute things with no side effects in a block.
+    //
+    // A BlockNode here means that somebody has a free-floating { }.
+    // Technically this can have side effects since it could generated targets,
+    // but we don't want to allow this since it creates ambiguity when
+    // immediately following a function call that takes no block. By not
+    // allowing free-floating blocks that aren't passed anywhere or assigned to
+    // anything, this ambiguity is resolved.
     const ParseNode* cur = statements_[i].get();
     if (cur->AsList() || cur->AsLiteral() || cur->AsUnaryOp() ||
-        cur->AsIdentifier()) {
+        cur->AsIdentifier() || cur->AsBlock()) {
       *err = cur->MakeErrorDescribing(
           "This statement has no effect.",
           "Either delete it or do something with the result.");
       return Value();
     }
-    cur->Execute(scope, err);
+    cur->Execute(execution_scope, err);
+  }
+
+  if (result_mode_ == RETURNS_SCOPE) {
+    // Clear the reference to the containing scope. This will be passed in
+    // a value whose lifetime will not be related to the enclosing_scope passed
+    // to this function.
+    nested_scope->DetachFromContaining();
+    return Value(this, std::move(nested_scope));
   }
   return Value();
 }
 
 LocationRange BlockNode::GetRange() const {
   if (begin_token_.type() != Token::INVALID &&
       end_->value().type() != Token::INVALID) {
     return begin_token_.range().Union(end_->value().range());
   } else if (!statements_.empty()) {
     return statements_[0]->GetRange().Union(
@@ skipping 505 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);
 }