Throw errors for nested targets in GN.

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"
@@ skipping 113 matching lines @@
 }
 
 Label MakeLabelForScope(const Scope* scope,
                         const FunctionCallNode* function,
                         const std::string& name) {
   const Label& toolchain_label = ToolchainLabelForScope(scope);
   return Label(scope->GetSourceDir(), name, toolchain_label.dir(),
                toolchain_label.name());
 }
 
+// static
+const int NonNestableBlock::kKey = 0;
+
+NonNestableBlock::NonNestableBlock(
+    Scope* scope,
+    const FunctionCallNode* function,
+    const char* type_description)
+    : scope_(scope),
+      function_(function),
+      type_description_(type_description),
+      key_added_(false) {
+}
+
+NonNestableBlock::~NonNestableBlock() {
+  if (key_added_)
+    scope_->SetProperty(&kKey, nullptr);
+}
+
+bool NonNestableBlock::Enter(Err* err) {
+  void* scope_value = scope_->GetProperty(&kKey, nullptr);
+  if (scope_value) {
+    // Existing block.
+    const NonNestableBlock* existing =
+        reinterpret_cast<const NonNestableBlock*>(scope_value);
+    *err = Err(function_, "Can't nest these things.",
+        std::string("You are trying to nest a ") + type_description_ +
+        " inside a " + existing->type_description_ + ".");
+    err->AppendSubErr(Err(existing->function_, "The enclosing block."));
+    return false;
+  }
+
+  scope_->SetProperty(&kKey, this);
+  key_added_ = true;
+  return true;
+}
+
 namespace functions {
 
 // assert ----------------------------------------------------------------------
 
 const char kAssert[] = "assert";
 const char kAssert_HelpShort[] =
     "assert: Assert an expression is true at generation time.";
 const char kAssert_Help[] =
     "assert: Assert an expression is true at generation time.\n"
     "\n"
@@ skipping 93 matching lines @@
     "  }\n"
     "\n"
     "  executable(\"mything\") {\n"
     "    configs = [ \":myconfig\" ]\n"
     "  }\n";
 
 Value RunConfig(const FunctionCallNode* function,
                 const std::vector<Value>& args,
                 Scope* scope,
                 Err* err) {
+  NonNestableBlock non_nestable(scope, function, "config");
+  if (!non_nestable.Enter(err))
+    return Value();
+
   if (!EnsureSingleStringArg(function, args, err) ||
       !EnsureNotProcessingImport(function, scope, err))
     return Value();
 
   Label label(MakeLabelForScope(scope, function, args[0].string_value()));
 
   if (g_scheduler->verbose_logging())
     g_scheduler->Log("Defining config", label.GetUserVisibleName(true));
 
   // Create the new config.
@@ skipping 44 matching lines @@
     "  If you want to override the (default disabled) Doom Melon:\n"
     "    gn --args=\"enable_doom_melon=true enable_teleporter=false\"\n"
     "  This also sets the teleporter, but it's already defaulted to on so\n"
     "  it will have no effect.\n";
 
 Value RunDeclareArgs(Scope* scope,
                      const FunctionCallNode* function,
                      const std::vector<Value>& args,
                      BlockNode* block,
                      Err* err) {
+  NonNestableBlock non_nestable(scope, function, "declare_args");
+  if (!non_nestable.Enter(err))
+    return Value();
+
   Scope block_scope(scope);
   block->Execute(&block_scope, err);
   if (err->has_error())
     return Value();
 
   // Pass the values from our scope into the Args object for adding to the
   // scope with the proper values (taking into account the defaults given in
   // the block_scope, and arguments passed into the build).
   Scope::KeyValueMap values;
   block_scope.GetCurrentScopeValues(&values);
@@ skipping 497 matching lines @@
   }
 
   // Otherwise it's a no-block function.
   if (!VerifyNoBlockForFunctionCall(function, block, err))
     return Value();
   return found_function->second.no_block_runner(scope, function,
                                                 args.list_value(), err);
 }
 
 }  // namespace functions