Add forward_variables_from() and target() to GN

tools/gn/scope.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_SCOPE_H_
 #define TOOLS_GN_SCOPE_H_
 
 #include <map>
 #include <set>
 
@@ skipping 50 matching lines @@
    protected:
     Scope* scope_;
   };
 
   // Options for configuring scope merges.
   struct MergeOptions {
     // Defaults to all false, which are the things least likely to cause errors.
     MergeOptions()
         : clobber_existing(false),
           skip_private_vars(false),
-          mark_used(false) {
+          mark_dest_used(false) {
     }
 
     // When set, all existing avlues in the destination scope will be
     // overwritten.
     //
     // When false, it will be an error to merge a variable into another scope
     // where a variable with the same name is already set. The exception is
     // if both of the variables have the same value (which happens if you
     // somehow multiply import the same file, for example). This case will be
     // ignored since there is nothing getting lost.
     bool clobber_existing;
 
     // When true, private variables (names beginning with an underscore) will
     // be copied to the destination scope. When false, private values will be
     // skipped.
     bool skip_private_vars;
 
     // When set, values copied to the destination scope will be marked as used
     // so won't trigger an unused variable warning. You want this when doing an
     // import, for example, or files that don't need a variable from the .gni
     // file will throw an error.
-    bool mark_used;
+    bool mark_dest_used;
   };
 
   // Creates an empty toplevel scope.
   explicit Scope(const Settings* settings);
 
   // Creates a dependent scope.
   explicit Scope(Scope* parent);
   explicit Scope(const Scope* parent);
 
   ~Scope();
@@ skipping 44 matching lines @@
   // Same as GetValue, but if the value exists in a parent scope, we'll copy
   // it to the current scope. If the return value is non-null, the value is
   // guaranteed to be set in the current scope. Generatlly this will be used
   // if the calling code is planning on modifying the value in-place.
   //
   // Since this is used when doing read-modifies, we never count this access
   // as reading the variable, since we assume it will be written to.
   Value* GetValueForcedToCurrentScope(const base::StringPiece& ident,
                                       const ParseNode* set_node);
 
+  // Returns the StringPiece used to identify the value. This string piece
+  // will have the same contents as "ident" passed in, but may point to a
+  // different underlying buffer. This is useful because this StringPiece is
+  // static and won't be deleted for the life of the program, so it can be used
+  // as keys in places that may outlive a temporary. It will return an empty
+  // string for programatic and nonexistant values.

[Dirk Pranke, 2015/08/03 21:12:24]

still have the "programmatic" typo

+  base::StringPiece GetStorageKey(const base::StringPiece& ident) const;
+
   // The set_node indicates the statement that caused the set, for displaying
   // errors later. Returns a pointer to the value in the current scope (a copy
   // is made for storage).
   Value* SetValue(const base::StringPiece& ident,
                   const Value& v,
                   const ParseNode* set_node);
 
   // Removes the value with the given identifier if it exists on the current
   // scope. This does not search recursive scopes. Does nothing if not found.
   void RemoveIdentifier(const base::StringPiece& ident);
 
   // Removes from this scope all identifiers and templates that are considered
   // private.
   void RemovePrivateIdentifiers();
 
   // Templates associated with this scope. A template can only be set once, so
   // AddTemplate will fail and return false if a rule with that name already
   // exists. GetTemplate returns NULL if the rule doesn't exist, and it will
   // check all containing scoped rescursively.
   bool AddTemplate(const std::string& name, const Template* templ);
   const Template* GetTemplate(const std::string& name) const;
 
   // Marks the given identifier as (un)used in the current scope.
   void MarkUsed(const base::StringPiece& ident);
+  void MarkAllUsed();
   void MarkUnused(const base::StringPiece& ident);
 
   // Checks to see if the scope has a var set that hasn't been used. This is
   // called before replacing the var with a different one. It does not check
   // containing scopes.
   //
   // If the identifier is present but hasnn't been used, return true.
   bool IsSetButUnused(const base::StringPiece& ident) const;
 
   // Checks the scope to see if any values were set but not used, and fills in
@@ skipping 153 matching lines @@
 
   typedef std::set<ProgrammaticProvider*> ProviderSet;
   ProviderSet programmatic_providers_;
 
   SourceDir source_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(Scope);
 };
 
 #endif  // TOOLS_GN_SCOPE_H_