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 620 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 not needed.";
+const char kNotNeeded_Help[] =
+    R"(not_needed: Mark variables from scope as not needed.
+
+  not_needed(variable_list_or_star, variable_to_ignore_list = [])
+  not_needed(from_scope, variable_list_or_star,
+             variable_to_ignore_list = [])
+
+  Mark the variables in the current or given scope as not needed, which means
+  you will not get an error about unused variables for these. The
+  variable_to_ignore_list allows excluding variables from "all matches" if
+  variable_list_or_star is "*".
+
+Example
+
+  not_needed("*", [ "config" ])
+  not_needed([ "data_deps", "deps" ])
+  not_needed(invoker, "*", [ "config" ])
+  not_needed(invoker, [ "data_deps", "deps" ])
+)";
+
+Value RunNotNeeded(Scope* scope,
+                   const FunctionCallNode* function,
+                   const ListNode* args_list,
+                   Err* err) {
+  const auto& args_vector = args_list->contents();
+  if (args_vector.size() < 1 && args_vector.size() > 3) {
+    *err = Err(function, "Wrong number of arguments.",
+               "Expecting one, two or three arguments.");
+    return Value();
+  }
+  auto args_cur = args_vector.begin();
+
+  Value* value = nullptr;  // Value to use, may point to result_value.
+  Value result_value;      // Storage for the "evaluate" case.
+  const IdentifierNode* identifier = (*args_cur)->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_cur)->Execute(scope, err);
+    if (err->has_error())
+      return Value();
+    value = &result_value;
+  }
+  args_cur++;
+
+  // Extract the source scope if different from current one.
+  Scope* source = scope;
+  if (value->type() == Value::SCOPE) {
+    source = value->scope_value();
+    result_value = (*args_cur)->Execute(scope, err);
+    if (err->has_error())
+      return Value();
+    value = &result_value;
+    args_cur++;
+  }
+
+  // Extract the exclusion list if defined.
+  Value exclusion_value;
+  std::set<std::string> exclusion_set;
+  if (args_cur != args_vector.end()) {
+    exclusion_value = (*args_cur)->Execute(source, 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());
+    }
+  }
+
+  if (value->type() == Value::STRING) {
+    if (value->string_value() == "*") {
+      source->MarkAllUsed(exclusion_set);
+      return Value();
+    }
+  } else if (value->type() == Value::LIST) {
+    if (exclusion_value.type() != Value::NONE) {
+      *err = Err(exclusion_value, "Not supported with a variable list.",
+                 "Exclusion list can only be used with the string \"*\".");
+      return Value();
+    }
+    for (const Value& cur : value->list_value()) {
+      if (!cur.VerifyTypeIs(Value::STRING, err))
+        return Value();
+      source->MarkUsed(cur.string_value());
+    }
+    return Value();
+  }
+
+  // Not the right type of argument.
+  *err = Err(*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