Document GN invoker and target name variables.

tools/gn/template.cc

 // 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.
 
 #include "tools/gn/template.h"
 
 #include <utility>
 
 #include "tools/gn/err.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/scope_per_file_provider.h"
 #include "tools/gn/value.h"
+#include "tools/gn/variables.h"
 
 Template::Template(const Scope* scope, const FunctionCallNode* def)
     : closure_(scope->MakeClosure()),
       definition_(def) {
 }
 
 Template::Template(std::unique_ptr<Scope> scope, const FunctionCallNode* def)
     : closure_(std::move(scope)), definition_(def) {}
 
 Template::~Template() {
@@ skipping 45 matching lines @@
   // Targets defined in the template go in the collector for the invoking file.
   template_scope.set_item_collector(scope->GetItemCollector());
 
   // We jump through some hoops to avoid copying the invocation scope when
   // setting it in the template scope (since the invocation scope may have
   // large lists of source files in it and could be expensive to copy).
   //
   // Scope.SetValue will copy the value which will in turn copy the scope, but
   // if we instead create a value and then set the scope on it, the copy can
   // be avoided.
-  const char kInvoker[] = "invoker";
-  template_scope.SetValue(kInvoker, Value(nullptr, std::unique_ptr<Scope>()),
-                          invocation);
-  Value* invoker_value = template_scope.GetMutableValue(kInvoker, false);
+  template_scope.SetValue(variables::kInvoker,
+                          Value(nullptr, std::unique_ptr<Scope>()), invocation);
+  Value* invoker_value =
+      template_scope.GetMutableValue(variables::kInvoker, false);
   invoker_value->SetScopeValue(std::move(invocation_scope));
   template_scope.set_source_dir(scope->GetSourceDir());
 
-  const base::StringPiece target_name("target_name");
+  const base::StringPiece target_name(variables::kTargetName);
   template_scope.SetValue(target_name,
                           Value(invocation, args[0].string_value()),
                           invocation);
 
   // Actually run the template code.
   Value result =
       definition_->block()->Execute(&template_scope, err);
   if (err->has_error()) {
     // If there was an error, append the caller location so the error message
     // displays a stack trace of how it got here.
     err->AppendSubErr(Err(invocation, "whence it was called."));
     return Value();
   }
 
   // Check for unused variables in the invocation scope. This will find typos
   // of things the caller meant to pass to the template but the template didn't
   // read out.
   //
   // This is a bit tricky because it's theoretically possible for the template
   // to overwrite the value of "invoker" and free the Scope owned by the
   // value. So we need to look it up again and don't do anything if it doesn't
   // exist.
-  invoker_value = template_scope.GetMutableValue(kInvoker, false);
+  invoker_value = template_scope.GetMutableValue(variables::kInvoker, false);
   if (invoker_value && invoker_value->type() == Value::SCOPE) {
     if (!invoker_value->scope_value()->CheckForUnusedVars(err))
       return Value();
   }
 
   // Check for unused variables in the template itself.
   if (!template_scope.CheckForUnusedVars(err))
     return Value();
 
   return result;
 }
 
 LocationRange Template::GetDefinitionRange() const {
   return definition_->GetRange();
 }