diff --git a/tools/gn/functions.cc b/tools/gn/functions.cc
index 0a00c9c..0102bd7 100644
--- a/tools/gn/functions.cc
+++ b/tools/gn/functions.cc
@@ -1036,13 +1036,14 @@
       function_map.find(name.value());
   if (found_function == function_map.end()) {
     // No built-in function matching this, check for a template.
-    const Template* templ =
-        scope->GetTemplate(function->function().value().as_string());
+    std::string template_name = function->function().value().as_string();
+    const Template* templ = scope->GetTemplate(template_name);
     if (templ) {
       Value args = args_list->Execute(scope, err);
       if (err->has_error())
         return Value();
-      return templ->Invoke(scope, function, args.list_value(), block, err);
+      return templ->Invoke(scope, function, template_name, args.list_value(),
+                           block, err);
     }
 
     *err = Err(name, "Unknown function.");
diff --git a/tools/gn/functions_target.cc b/tools/gn/functions_target.cc
index 4e162d5..8aa7f93 100644
--- a/tools/gn/functions_target.cc
+++ b/tools/gn/functions_target.cc
@@ -773,7 +773,7 @@
   // Run a template if it is one.
   const Template* templ = scope->GetTemplate(target_type);
   if (templ)
-    return templ->Invoke(scope, function, sub_args, block, err);
+    return templ->Invoke(scope, function, target_type, sub_args, block, err);
 
   // Otherwise, assume the target is a built-in target type.
   return ExecuteGenericTarget(target_type.c_str(), scope, function, sub_args,
diff --git a/tools/gn/functions_target_unittest.cc b/tools/gn/functions_target_unittest.cc
index a7a0de9..f4eeb38 100644
--- a/tools/gn/functions_target_unittest.cc
+++ b/tools/gn/functions_target_unittest.cc
@@ -36,3 +36,37 @@
   source_set_input.parsed()->Execute(setup.scope(), &err);
   ASSERT_TRUE(err.has_error());
 }
+
+// Checks that the defaults applied to a template invoked by target() use
+// the name of the template, rather than the string "target" (which is the
+// name of the actual function being called).
+TEST(FunctionsTarget, TemplateDefaults) {
+  Scheduler scheduler;
+  TestWithScope setup;
+
+  // The target generator needs a place to put the targets or it will fail.
+  Scope::ItemVector item_collector;
+  setup.scope()->set_item_collector(&item_collector);
+
+  // Test a good one first.
+  TestParseInput good_input(
+      // Make a template with defaults set.
+      "template(\"my_templ\") {\n"
+      "  source_set(target_name) {\n"
+      "    forward_variables_from(invoker, \"*\")\n"
+      "  }\n"
+      "}\n"
+      "set_defaults(\"my_templ\") {\n"
+      "  default_value = 1\n"
+      "}\n"
+
+      // Invoke the template with target(). This will fail to execute if the
+      // defaults were not set properly, because "default_value" won't exist.
+      "target(\"my_templ\", \"foo\") {\n"
+      "  print(default_value)\n"
+      "}\n");
+  ASSERT_FALSE(good_input.has_error());
+  Err err;
+  good_input.parsed()->Execute(setup.scope(), &err);
+  ASSERT_FALSE(err.has_error()) << err.message();
+}
diff --git a/tools/gn/template.cc b/tools/gn/template.cc
index 8b8ae69..3c4d76d 100644
--- a/tools/gn/template.cc
+++ b/tools/gn/template.cc
@@ -26,6 +26,7 @@
 
 Value Template::Invoke(Scope* scope,
                        const FunctionCallNode* invocation,
+                       const std::string& template_name,
                        const std::vector<Value>& args,
                        BlockNode* block,
                        Err* err) const {
@@ -37,8 +38,7 @@
   // 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();
 
diff --git a/tools/gn/template.h b/tools/gn/template.h
index a79d82f..da5a1a4 100644
--- a/tools/gn/template.h
+++ b/tools/gn/template.h
@@ -33,9 +33,12 @@
   Template(std::unique_ptr<Scope> closure, const FunctionCallNode* def);
 
   // Invoke the template. The values correspond to the state of the code
-  // invoking the template.
+  // invoking the template. The template name needs to be supplied since the
+  // template object itself doesn't know what name the calling code is using
+  // to refer to it (this is used to set defaults).
   Value Invoke(Scope* scope,
                const FunctionCallNode* invocation,
+               const std::string& template_name,
                const std::vector<Value>& args,
                BlockNode* block,
                Err* err) const;