GN: Use the correct defaults for templates invoked via target().

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"
 
 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() {
 }
 
 Value Template::Invoke(Scope* scope,
                        const FunctionCallNode* invocation,
+                       const std::string& template_name,
                        const std::vector<Value>& args,
                        BlockNode* block,
                        Err* err) const {
   // Don't allow templates to be executed from imported files. Imports are for
   // simple values only.
   if (!EnsureNotProcessingImport(invocation, scope, err))
     return Value();
 
   // First run the invocation's block. Need to allocate the scope on the heap
   // so we can pass ownership to the template.
   std::unique_ptr<Scope> invocation_scope(new Scope(scope));
-  if (!FillTargetBlockScope(scope, invocation,
-                            invocation->function().value().as_string(),
+  if (!FillTargetBlockScope(scope, invocation, template_name,
                             block, args, invocation_scope.get(), err))
     return Value();
 
   {
     // Don't allow the block of the template invocation to include other
     // targets configs, or template invocations. This must only be applied
     // to the invoker's block rather than the whole function because the
     // template execution itself must be able to define targets, etc.
     NonNestableBlock non_nestable(scope, invocation, "template invocation");
     if (!non_nestable.Enter(err))
@@ skipping 64 matching lines @@
   // Check for unused variables in the template itself.
   if (!template_scope.CheckForUnusedVars(err))
     return Value();
 
   return result;
 }
 
 LocationRange Template::GetDefinitionRange() const {
   return definition_->GetRange();
 }