Don't dynamically scope GN templates.

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>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
 #include "tools/gn/err.h"
 #include "tools/gn/pattern.h"
 #include "tools/gn/source_dir.h"
 #include "tools/gn/value.h"
 
 class FunctionCallNode;
 class ImportManager;
 class ParseNode;
 class Settings;
 class TargetManager;
+class Template;
 
 // Scope for the script execution.
 //
 // Scopes are nested. Writing goes into the toplevel scope, reading checks
 // values resursively down the stack until a match is found or there are no
 // more containing scopes.
 //
 // A containing scope can be const or non-const. The const containing scope is
 // used primarily to refer to the master build config which is shared across
 // many invocations. A const containing scope, however, prevents us from
@@ skipping 87 matching lines @@
                                       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);
 
   // Templates associated with this scope. A template can only be set once, so
-  // AddTemplate will fail and return NULL if a rule with that name already
+  // 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 FunctionCallNode* decl);
-  const FunctionCallNode* GetTemplate(const std::string& name) const;
+  bool AddTemplate(const std::string& name, scoped_ptr<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;
 
   // 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").
   //
-  // It is 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.
+  // 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 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).
+  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;
 
   // Filter to apply when the sources variable is assigned. May return NULL.
   const PatternList* GetSourcesAssignmentFilter() const;
@@ skipping 74 matching lines @@
   // Owning pointers. Note that this can't use string pieces since the names
   // are constructed from Values which might be deallocated before this goes
   // out of scope.
   typedef base::hash_map<std::string, Scope*> NamedScopeMap;
   NamedScopeMap target_defaults_;
 
   // Null indicates not set and that we should fallback to the containing
   // scope's filter.
   scoped_ptr<PatternList> sources_assignment_filter_;
 
-  // Non-owning pointers, the function calls are owned by the input file which
-  // should be kept around by the input file manager.
-  typedef std::map<std::string, const FunctionCallNode*> TemplateMap;
+  // Owning pointers, must be deleted.
+  typedef std::map<std::string, const Template*> TemplateMap;
   TemplateMap templates_;
 
   // Opaque pointers. See SetProperty() above.
   typedef std::map<const void*, void*> PropertyMap;
   PropertyMap properties_;
 
   typedef std::set<ProgrammaticProvider*> ProviderSet;
   ProviderSet programmatic_providers_;
 
   SourceDir source_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(Scope);
 };
 
 #endif  // TOOLS_GN_SCOPE_H_