Allow creation and modification of scopes in GN.

tools/gn/parse_tree.h

 // Copyright 2014 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_PARSE_TREE_H_
 #define TOOLS_GN_PARSE_TREE_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 142 matching lines @@
   const ParseNode* index() const { return index_.get(); }
   void set_index(std::unique_ptr<ParseNode> i) { index_ = std::move(i); }
 
   // The member is the identifier on the right hand side of the dot. Will be
   // null if the index is set.
   const IdentifierNode* member() const { return member_.get(); }
   void set_member(std::unique_ptr<IdentifierNode> i) { member_ = std::move(i); }
 
   void SetNewLocation(int line_number);
 
+  // Evaluates the index for list accessor operations and range checks it
+  // against the max length of the list. If the index is OK, sets
+  // |*computed_index| and returns true. Otherwise sets the |*err| and returns
+  // false.
+  bool ComputeAndValidateListIndex(Scope* scope,
+                                   size_t max_len,
+                                   size_t* computed_index,
+                                   Err* err) const;
+
  private:
   Value ExecuteArrayAccess(Scope* scope, Err* err) const;
   Value ExecuteScopeAccess(Scope* scope, Err* err) const;
 
   Token base_;
 
   // Either index or member will be set according to what type of access this
   // is.
   std::unique_ptr<ParseNode> index_;
   std::unique_ptr<IdentifierNode> member_;
@@ skipping 32 matching lines @@
   Token op_;
   std::unique_ptr<ParseNode> right_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryOpNode);
 };
 
 // BlockNode -------------------------------------------------------------------
 
 class BlockNode : public ParseNode {
  public:
-  BlockNode();
+  // How Execute manages the scopes and results.
+  enum ResultMode {
+    // Creates a new scope for the execution of this block and returns it as
+    // a Value from Execute().
+    RETURNS_SCOPE,
+
+    // Executes in the context of the calling scope (variables set will go
+    // into the invoking scope) and Execute will return an empty Value.
+    DISCARDS_RESULT
+  };
+
+  BlockNode(ResultMode result_mode);
   ~BlockNode() override;
 
   const BlockNode* AsBlock() const override;
   Value Execute(Scope* scope, Err* err) const override;
   LocationRange GetRange() const override;
   Err MakeErrorDescribing(
       const std::string& msg,
       const std::string& help = std::string()) const override;
   void Print(std::ostream& out, int indent) const override;
 
   void set_begin_token(const Token& t) { begin_token_ = t; }
   void set_end(std::unique_ptr<EndNode> e) { end_ = std::move(e); }
   const EndNode* End() const { return end_.get(); }
 
+  ResultMode result_mode() const { return result_mode_; }
+
   const std::vector<std::unique_ptr<ParseNode>>& statements() const {
     return statements_;
   }
   void append_statement(std::unique_ptr<ParseNode> s) {
     statements_.push_back(std::move(s));
   }
 
  private:
+  const ResultMode result_mode_;
+
   // Tokens corresponding to { and }, if any (may be NULL). The end is stored
   // in a custom parse node so that it can have comments hung off of it.
   Token begin_token_;
   std::unique_ptr<EndNode> end_;
 
   std::vector<std::unique_ptr<ParseNode>> statements_;
 
   DISALLOW_COPY_AND_ASSIGN(BlockNode);
 };
 
@@ skipping 265 matching lines @@
   const Token& value() const { return value_; }
   void set_value(const Token& t) { value_ = t; }
 
  private:
   Token value_;
 
   DISALLOW_COPY_AND_ASSIGN(EndNode);
 };
 
 #endif  // TOOLS_GN_PARSE_TREE_H_