Support private values in 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 47 matching lines @@
 
     // Returns a non-null value if the given value can be programmatically
     // generated, or NULL if there is none.
     virtual const Value* GetProgrammaticValue(
         const base::StringPiece& ident) = 0;
 
    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) {
+    }
+
+    // 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;
+  };
+
   // Creates an empty toplevel scope.
   Scope(const Settings* settings);
 
   // Creates a dependent scope.
   Scope(Scope* parent);
   Scope(const Scope* parent);
 
   ~Scope();
 
   const Settings* settings() const { return settings_; }
@@ skipping 53 matching lines @@
   // 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 MarkUnused(const base::StringPiece& ident);
@@ skipping 11 matching lines @@
 
   // Returns all values set in the current scope, without going to the parent
   // scopes.
   void GetCurrentScopeValues(KeyValueMap* output) const;
 
   // Copies this scope's values into the destination. Values from the
   // containing scope(s) (normally shadowed into the current one) will not be
   // copied, neither will the reference to the containing scope (this is why
   // it's "non-recursive").
   //
-  // If clobber_existing is true, any existing values will be overwritten. In
-  // this mode, this function will never fail.
-  //
-  // If clobber_existing is false, it will be an error to merge a variable into
-  // a scope that already has something with that name in scope (meaning in
-  // that scope or in any of its containing scopes). If this happens, the error
-  // will be set and the function will return false.
-  //
   // This is used in different contexts. When generating the error, the given
   // parse node will be blamed, and the given desc will be used to describe
   // the operation that doesn't support doing this. For example, desc_for_err
   // would be "import" when doing an import, and the error string would say
   // something like "The import contains...".
   bool NonRecursiveMergeTo(Scope* dest,
-                           bool clobber_existing,
+                           const MergeOptions& options,
                            const ParseNode* node_for_err,
                            const char* desc_for_err,
                            Err* err) const;
 
   // Constructs a scope that is a copy of the current one. Nested scopes will
-  // be collapsed until we reach a const containing scope. The resulting
-  // closure will reference the const containing scope as its containing scope
-  // (since we assume the const scope won't change, we don't have to copy its
-  // values).
+  // be collapsed until we reach a const containing scope. Private values will
+  // be included. The resulting closure will reference the const containing
+  // scope as its containing scope (since we assume the const scope won't
+  // change, we don't have to copy its values).
   scoped_ptr<Scope> MakeClosure() const;
 
   // Makes an empty scope with the given name. Returns NULL if the name is
   // already set.
   Scope* MakeTargetDefaults(const std::string& target_type);
 
   // Gets the scope associated with the given target name, or null if it hasn't
   // been set.
   const Scope* GetTargetDefaults(const std::string& target_type) const;
 
@@ skipping 115 matching lines @@
 
   typedef std::set<ProgrammaticProvider*> ProviderSet;
   ProviderSet programmatic_providers_;
 
   SourceDir source_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(Scope);
 };
 
 #endif  // TOOLS_GN_SCOPE_H_