Fixes to {} handling 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"
 #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 {
+
+// Some functions take a {} following them, and some don't. For the ones that
+// don't, this is used to verify that the given block node is null and will
+// set the error accordingly if it's not. Returns true if the block is null.
+bool VerifyNoBlockForFunctionCall(const FunctionCallNode* function,
+                                  const BlockNode* block,
+                                  Err* err) {
+  if (!block)
+    return true;
+
+  *err = Err(block, "Unexpected '{'.",
+      "This function call doesn't take a {} block following it, and you\n"
+      "can't have a {} block that's not connected to something like an if\n"
+      "statement or a target declaration.");
+  err->AppendRange(function->function().range());
+  return false;
+}
+
+}  // 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 704 matching lines @@
       if (err->has_error())
         return Value();
       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) {
+    // Self evaluating args functions are special weird built-ins. Currently,
+    // only foreach() takes a block following it. Rather than force them all to
+    // check that they have a block or no block and risk bugs for new additions,
+    // check a whitelist here.
+    if (found_function->second.self_evaluating_args_runner != &RunForEach) {
+      if (!VerifyNoBlockForFunctionCall(function, block, err))
+        return Value();
+    }
     return found_function->second.self_evaluating_args_runner(
         scope, function, args_list, err);
   }
 
   // All other function types take a pre-executed set of args.
   Value args = args_list->Execute(scope, err);
   if (err->has_error())
     return Value();
 
   if (found_function->second.generic_block_runner) {
@@ skipping 20 matching lines @@
         function, args.list_value(), &block_scope, err);
     if (err->has_error())
       return Value();
 
     if (!block_scope.CheckForUnusedVars(err))
       return Value();
     return result;
   }
 
   // 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