Add not_needed function

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 <stddef.h>
 #include <iostream>
 #include <utility>
 
@@ skipping 116 matching lines @@
 
   // 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.
   const base::StringPiece target_name(variables::kTargetName);
   block_scope->SetValue(target_name, Value(function, args[0].string_value()),
                         function);
-  block_scope->MarkUsed(target_name);
+  block_scope->MarkUsed(target_name, err);
   return true;
 }
 
 void FillNeedsBlockError(const FunctionCallNode* function, Err* err) {
   *err = Err(function->function(), "This function call requires a block.",
       "The block's \"{\" must be on the same line as the function "
       "call's \")\".");
 }
 
 bool EnsureSingleStringArg(const FunctionCallNode* function,
@@ skipping 483 matching lines @@
   SourceFile import_file =
       input_dir.ResolveRelativeFile(args[0], err,
           scope->settings()->build_settings()->root_path_utf8());
   if (!err->has_error()) {
     scope->settings()->import_manager().DoImport(import_file, function,
                                                  scope, err);
   }
   return Value();
 }
 
+// not_needed -----------------------------------------------------------------
+
+const char kNotNeeded[] = "not_needed";
+const char kNotNeeded_HelpShort[] =
+    "not_needed: Mark variables from scope as unusedd.";

[brettw, 2017/06/20 17:27:25]

"unusedd" spelling

[Petr Hosek, 2017/06/21 02:17:40]

Done.

+const char kNotNeeded_Help[] =
+    R"(not_needed: Mark variables from scope as unused.
+
+  not_needed(from_scope, variable_list_or_star,
+             variable_to_ignore_list = [])
+
+  Mark the variables from the given scope as not being used in the current
+  scope. Any past or future uses of these variables within the current scope
+  will fail with an error.
+
+Example
+
+  not_needed(invoker, "*", [ "config" ])
+  not_needed(invoker, [ "data_deps", "deps" ])

[brettw, 2017/06/20 17:27:25]

Can you add support for a third form that modifies the current scope? I think we
can do this by just marking the first argument as optional. This should be easy
to tell by what types things are.
  not_needed([ "config" ])
  not_needed("*", [ "config" ])
We probably don't need the "*" form for this, but then I think it gets too
complicated to explain, so may as well keep it.

The need for this comes up in legitimate cases, especially in the Android
templates which have insane conditionals and its' really difficult to tell when
things will be needed in advance:

https://cs.chromium.org/chromium/src/build/config/android/internal_rules.gni?...

https://cs.chromium.org/chromium/src/build/config/android/internal_rules.gni?...

To support this case, I think we can remove the concept of "unusable' variables.
There can be nice uses of this, but it does prevent others like the Android
ones, and I'm not sure the practical value is so great.

I think then you can remove some of the out err values for the Scope functions
which will make this patch smaller.

[Petr Hosek, 2017/06/21 02:17:40]

Done.

+)";
+
+Value RunNotNeeded(Scope* scope,
+                   const FunctionCallNode* function,
+                   const ListNode* args_list,
+                   Err* err) {
+  const auto& args_vector = args_list->contents();
+  if (args_vector.size() != 2 && args_vector.size() != 3) {
+    *err = Err(function, "Wrong number of arguments.",
+               "Expecting two or three arguments.");
+    return Value();
+  }
+
+  Value* value = nullptr;  // Value to use, may point to result_value.
+  Value result_value;      // Storage for the "evaluate" case.
+  const IdentifierNode* identifier = args_vector[0]->AsIdentifier();
+  if (identifier) {
+    // Optimize the common case where the input scope is an identifier. This
+    // prevents a copy of a potentially large Scope object.
+    value = scope->GetMutableValue(identifier->value().value(),
+                                   Scope::SEARCH_NESTED, true);
+    if (!value) {
+      *err = Err(identifier, "Undefined identifier.");
+      return Value();
+    }
+  } else {
+    // Non-optimized case, just evaluate the argument.
+    result_value = args_vector[0]->Execute(scope, err);
+    if (err->has_error())
+      return Value();
+    value = &result_value;
+  }
+
+  // Extract the source scope.
+  if (!value->VerifyTypeIs(Value::SCOPE, err))
+    return Value();
+  Scope* source = value->scope_value();
+
+  // Extract the exclusion list if defined.
+  std::set<std::string> exclusion_set;
+  if (args_vector.size() == 3) {
+    Value exclusion_value = args_vector[2]->Execute(scope, err);
+    if (err->has_error())
+      return Value();
+
+    if (exclusion_value.type() != Value::LIST) {
+      *err = Err(exclusion_value, "Not a valid list of variables to exclude.",
+                 "Expecting a list of strings.");
+      return Value();
+    }
+
+    for (const Value& cur : exclusion_value.list_value()) {
+      if (!cur.VerifyTypeIs(Value::STRING, err))
+        return Value();
+
+      exclusion_set.insert(cur.string_value());
+    }
+  }
+
+  // Extract the list. If all_values is not set, the what_value will be a list.
+  Value what_value = args_vector[1]->Execute(scope, err);
+  if (err->has_error())
+    return Value();
+  if (what_value.type() == Value::STRING) {
+    if (what_value.string_value() == "*") {
+      source->MarkAllUnusable(err, exclusion_set);
+      return Value();
+    }
+  } else {
+    if (what_value.type() == Value::LIST) {
+      for (const Value& cur : what_value.list_value()) {
+        if (!cur.VerifyTypeIs(Value::STRING, err))
+          return Value();
+        source->MarkUnusable(cur.string_value(), err);
+      }
+      return Value();
+    }
+  }
+
+  // Not the right type of argument.
+  *err = Err(what_value, "Not a valid list of variables.",
+             "Expecting either the string \"*\" or a list of strings.");
+  return Value();
+}
+
 // set_sources_assignment_filter -----------------------------------------------
 
 const char kSetSourcesAssignmentFilter[] = "set_sources_assignment_filter";
 const char kSetSourcesAssignmentFilter_HelpShort[] =
     "set_sources_assignment_filter: Set a pattern to filter source files.";
 const char kSetSourcesAssignmentFilter_Help[] =
     R"(set_sources_assignment_filter: Set a pattern to filter source files.
 
   The sources assignment filter is a list of patterns that remove files from
   the list implicitly whenever the "sources" variable is assigned to. This will
@@ skipping 382 matching lines @@
     INSERT_FUNCTION(DeclareArgs, false)
     INSERT_FUNCTION(Defined, false)
     INSERT_FUNCTION(ExecScript, false)
     INSERT_FUNCTION(ForEach, false)
     INSERT_FUNCTION(ForwardVariablesFrom, false)
     INSERT_FUNCTION(GetEnv, false)
     INSERT_FUNCTION(GetLabelInfo, false)
     INSERT_FUNCTION(GetPathInfo, false)
     INSERT_FUNCTION(GetTargetOutputs, false)
     INSERT_FUNCTION(Import, false)
+    INSERT_FUNCTION(NotNeeded, false)
     INSERT_FUNCTION(Pool, false)
     INSERT_FUNCTION(Print, false)
     INSERT_FUNCTION(ProcessFileTemplate, false)
     INSERT_FUNCTION(ReadFile, false)
     INSERT_FUNCTION(RebasePath, false)
     INSERT_FUNCTION(SetDefaults, false)
     INSERT_FUNCTION(SetDefaultToolchain, false)
     INSERT_FUNCTION(SetSourcesAssignmentFilter, false)
     INSERT_FUNCTION(SplitList, false)
     INSERT_FUNCTION(Template, false)
@@ skipping 84 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