Don't dynamically scope GN templates.

tools/gn/functions.cc

 // 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.
 
 #include "tools/gn/functions.h"
 
 #include <iostream>
 
 #include "base/environment.h"
 #include "base/strings/string_util.h"
 #include "tools/gn/config.h"
 #include "tools/gn/config_values_generator.h"
 #include "tools/gn/err.h"
 #include "tools/gn/input_file.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/settings.h"
+#include "tools/gn/template.h"
 #include "tools/gn/token.h"
 #include "tools/gn/value.h"
 
-namespace {
-
-// This is called when a template is invoked. When we see a template
-// declaration, that funciton is RunTemplate.
-Value RunTemplateInvocation(Scope* scope,
-                            const FunctionCallNode* invocation,
-                            const std::vector<Value>& args,
-                            BlockNode* block,
-                            const FunctionCallNode* rule,
-                            Err* err) {
-  if (!EnsureNotProcessingImport(invocation, scope, err))
-    return Value();
-
-  Scope block_scope(scope);
-  if (!FillTargetBlockScope(scope, invocation,
-                            invocation->function().value().as_string(),
-                            block, args, &block_scope, err))
-    return Value();
-
-  // Run the block for the rule invocation.
-  block->ExecuteBlockInScope(&block_scope, err);
-  if (err->has_error())
-    return Value();
-
-  // Now run the rule itself with that block as the current scope.
-  rule->block()->ExecuteBlockInScope(&block_scope, err);
-  if (err->has_error())
-    return Value();
-
-  block_scope.CheckForUnusedVars(err);
-  return Value();
-}
-
-}  // namespace
-
-// ----------------------------------------------------------------------------
-
 bool EnsureNotProcessingImport(const ParseNode* node,
                                const Scope* scope,
                                Err* err) {
   if (scope->IsProcessingImport()) {
     *err = Err(node, "Not valid from an import.",
         "Imports are for defining defaults, variables, and rules. The\n"
         "appropriate place for this kind of thing is really in a normal\n"
         "BUILD file.");
     return false;
   }
@@ skipping 21 matching lines @@
                           Err* err) {
   if (!block) {
     FillNeedsBlockError(function, err);
     return false;
   }
 
   // Copy the target defaults, if any, into the scope we're going to execute
   // the block in.
   const Scope* default_scope = scope->GetTargetDefaults(target_type);
   if (default_scope) {
-    if (!default_scope->NonRecursiveMergeTo(block_scope, function,
+    if (!default_scope->NonRecursiveMergeTo(block_scope, false, function,
                                             "target defaults", err))
       return false;
   }
 
   // The name is the single argument to the target function.
   if (!EnsureSingleStringArg(function, args, err))
     return false;
 
   // Set the target name variable to the current target, and mark it used
   // because we don't want to issue an error if the script ignores it.
@@ skipping 213 matching lines @@
 
 // defined ---------------------------------------------------------------------
 
 const char kDefined[] = "defined";
 const char kDefined_Help[] =
     "defined: Returns whether an identifier is defined.\n"
     "\n"
     "  Returns true if the given argument is defined. This is most useful in\n"
     "  templates to assert that the caller set things up properly.\n"
     "\n"
+    "  You can pass an identifier:\n"
+    "    defined(foo)\n"
+    "  which will return true or false depending on whether foo is defined in\n"
+    "  the current scope.\n"
+    "\n"
+    "  You can also check a named scope:\n"
+    "    defined(foo.bar)\n"
+    "  which returns true if both foo is defined and bar is defined on the\n"
+    "  named scope foo. It will throw an error if foo is defined but is not\n"
+    "  a scope.\n"
+    "\n"
     "Example:\n"
     "\n"
     "  template(\"mytemplate\") {\n"
     "    # To help users call this template properly...\n"
-    "    assert(defined(sources), \"Sources must be defined\")\n"
+    "    assert(defined(invoker.sources), \"Sources must be defined\")\n"
     "\n"
     "    # If we want to accept an optional \"values\" argument, we don't\n"
     "    # want to dereference something that may not be defined.\n"
-    "    if (!defined(outputs)) {\n"
-    "      outputs = []\n"
+    "    if (defined(invoker.values)) {\n"
+    "      values = invoker.values\n"
+    "    } else {\n"
+    "      values = \"some default value\"\n"
     "    }\n"
     "  }\n";
 
 Value RunDefined(Scope* scope,
                  const FunctionCallNode* function,
                  const ListNode* args_list,
                  Err* err) {
   const std::vector<const ParseNode*>& args_vector = args_list->contents();
-  const IdentifierNode* identifier = NULL;
-  if (args_vector.size() != 1 ||
-      !(identifier = args_vector[0]->AsIdentifier())) {
-    *err = Err(function, "Bad argument to defined().",
-        "defined() takes one argument which should be an identifier.");
+  if (args_vector.size() != 1) {
+    *err = Err(function, "Wrong number of arguments to defined().",
+               "Expecting exactly one.");
     return Value();
   }
 
-  if (scope->GetValue(identifier->value().value()))
-    return Value(function, true);
-  return Value(function, false);
+  const IdentifierNode* identifier = args_vector[0]->AsIdentifier();
+  if (identifier) {
+    // Passed an identifier "defined(foo)".
+    if (scope->GetValue(identifier->value().value()))
+      return Value(function, true);
+    return Value(function, false);
+  }
+
+  const AccessorNode* accessor = args_vector[0]->AsAccessor();
+  if (accessor) {
+    // Passed an accessor "defined(foo.bar)".
+    if (accessor->member()) {
+      // The base of the accessor must be a scope if it's defined.
+      const Value* base = scope->GetValue(accessor->base().value());
+      if (!base)
+        return Value(function, false);
+      if (!base->VerifyTypeIs(Value::SCOPE, err))
+        return Value();
+
+      // Check the member inside the scope to see if its defined.
+      if (base->scope_value()->GetValue(accessor->member()->value().value()))
+        return Value(function, true);
+      return Value(function, false);
+    }
+  }
+
+  // Argument is invalid.
+  *err = Err(function, "Bad thing passed to defined().",
+      "It should be of the form defined(foo) or defined(foo.bar).");
+  return Value();
 }
 
 // getenv ----------------------------------------------------------------------
 
 const char kGetEnv[] = "getenv";
 const char kGetEnv_Help[] =
     "getenv: Get an environment variable.\n"
     "\n"
     "  value = getenv(env_var_name)\n"
     "\n"
@@ skipping 245 matching lines @@
                   const ListNode* args_list,
                   BlockNode* block,
                   Err* err) {
   const Token& name = function->function();
 
   const FunctionInfoMap& function_map = GetFunctions();
   FunctionInfoMap::const_iterator found_function =
       function_map.find(name.value());
   if (found_function == function_map.end()) {
     // No built-in function matching this, check for a template.
-    const FunctionCallNode* rule =
+    const Template* templ =
         scope->GetTemplate(function->function().value().as_string());
-    if (rule) {
+    if (templ) {
       Value args = args_list->Execute(scope, err);
       if (err->has_error())
         return Value();
-      return RunTemplateInvocation(scope, function, args.list_value(), block,
-                                   rule, err);
+      return templ->Invoke(scope, function, args.list_value(), block, err);
     }
 
     *err = Err(name, "Unknown function.");
     return Value();
   }
 
   if (found_function->second.self_evaluating_args_runner) {
     return found_function->second.self_evaluating_args_runner(
         scope, function, args_list, err);
   }
@@ skipping 25 matching lines @@
     return found_function->second.executed_block_runner(
         function, args.list_value(), &block_scope, err);
   }
 
   // Otherwise it's a no-block function.
   return found_function->second.no_block_runner(scope, function,
                                                 args.list_value(), err);
 }
 
 }  // namespace functions