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 are the things least likely to cause errors.
+    MergeOptions()
+        : clobber_existing(false),
+          copy_private_vars(true),

[cjhopman, 2014/05/14 16:42:43]

nit: how about clear_private_vars so that the defaults can all be false?

[brettw, 2014/05/15 19:44:15]

Done.

+          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 copy_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 49 matching lines @@
   Value* GetValueForcedToCurrentScope(const base::StringPiece& ident,
                                       const ParseNode* set_node);
 
   // 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);
 
+  // Deletes the given named value from the current scope if it exists.
+  void DeleteValue(const base::StringPiece& ident);
+
   // 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);
 
   // 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
   // the error and returns false if they were.
   bool CheckForUnusedVars(Err* err) const;
 
   // Returns all values set in the current scope, without going to the parent
   // scopes.
   void GetCurrentScopeValues(KeyValueMap* output) const;
+  void GetCurrentScopeVariables(std::vector<base::StringPiece>* 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 54 matching lines @@
   // The key should be a pointer to some use-case-specific object (to avoid
   // collisions, otherwise it doesn't matter). Memory management is up to the
   // setter. Setting the value to NULL will delete the property.
   //
   // Getting a property recursively searches all scopes, and the optional
   // |found_on_scope| variable will be filled with the actual scope containing
   // the key (if the pointer is non-NULL).
   void SetProperty(const void* key, void* value);
   void* GetProperty(const void* key, const Scope** found_on_scope) const;
 
+  // Returns true if this variable name should be considered private. Private
+  // values start with an underscore, and are not imported from "gni" files
+  // when processing an import.
+  static bool IsPrivateVar(const base::StringPiece& name);
+
  private:
   friend class ProgrammaticProvider;
 
   struct Record {
     Record() : used(false) {}
     Record(const Value& v) : used(false), value(v) {}
 
     bool used;  // Set to true when the variable is used.
     Value value;
   };
@@ skipping 41 matching lines @@
 
   typedef std::set<ProgrammaticProvider*> ProviderSet;
   ProviderSet programmatic_providers_;
 
   SourceDir source_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(Scope);
 };
 
 #endif  // TOOLS_GN_SCOPE_H_