Add not_needed function

tools/gn/scope.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/scope.h"
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/template.h"
@@ skipping 187 matching lines @@
 
 const Template* Scope::GetTemplate(const std::string& name) const {
   TemplateMap::const_iterator found = templates_.find(name);
   if (found != templates_.end())
     return found->second.get();
   if (containing())
     return containing()->GetTemplate(name);
   return nullptr;
 }
 
-void Scope::MarkUsed(const base::StringPiece& ident) {
+void Scope::MarkUsed(const base::StringPiece& ident, Err* err) {
   RecordMap::iterator found = values_.find(ident);
   if (found == values_.end()) {
     NOTREACHED();
     return;
   }
+  if (found->second.unusable) {
+    *err = Err(found->second.value.origin(), "Variable was marked as unused.",
+               "You marked the variable \"" + found->first.as_string() +
+                   "\" as unused, but it is being used.");
+    return;
+  }
   found->second.used = true;
 }
 
-void Scope::MarkAllUsed() {
-  for (auto& cur : values_)
+void Scope::MarkAllUsed(Err* err) {
+  for (auto& cur : values_) {
+    if (cur.second.unusable) {
+      *err = Err(cur.second.value.origin(), "Variable was marked as unused.",
+                 "You marked the variable \"" + cur.first.as_string() +
+                     "\" as unused, but it is being used.");
+      return;
+    }
     cur.second.used = true;
+  }
 }
 
 void Scope::MarkUnused(const base::StringPiece& ident) {
   RecordMap::iterator found = values_.find(ident);
   if (found == values_.end()) {
     NOTREACHED();
     return;
   }
   found->second.used = false;
 }
 
+void Scope::MarkAllUnusable(Err* err, std::set<std::string> excluded_values) {
+  for (auto& cur : values_) {
+    if (!excluded_values.empty() &&
+        excluded_values.find(cur.first.as_string()) != excluded_values.end()) {
+      continue;  // Skip this excluded value.
+    }
+
+    if (cur.second.used) {
+      *err = Err(cur.second.value.origin(), "Variable was marked as unused.",
+                 "You marked the variable \"" + cur.first.as_string() +
+                     "\" as unused, but it is being used.");
+      return;
+    }
+    cur.second.unusable = true;
+  }
+}
+
+void Scope::MarkUnusable(const base::StringPiece& ident, Err* err) {
+  RecordMap::iterator found = values_.find(ident);
+  if (found == values_.end()) {
+    NOTREACHED();
+    return;
+  }
+  if (found->second.used) {
+    *err = Err(found->second.value.origin(), "Variable was marked as unused.",
+               "You marked the variable \"" + ident.as_string() +
+                   "\" as unused, but it is being used.");
+    return;
+  }
+  found->second.unusable = true;
+}
+
 bool Scope::IsSetButUnused(const base::StringPiece& ident) const {
   RecordMap::const_iterator found = values_.find(ident);
   if (found != values_.end()) {
     if (!found->second.used) {
       return true;
     }
   }
   return false;
 }
 
 bool Scope::CheckForUnusedVars(Err* err) const {
   for (const auto& pair : values_) {
-    if (!pair.second.used) {
+    if (!pair.second.unusable && !pair.second.used) {
       std::string help = "You set the variable \"" + pair.first.as_string() +
           "\" here and it was unused before it went\nout of scope.";
 
       const BinaryOpNode* binary = pair.second.value.origin()->AsBinaryOp();
       if (binary && binary->op().type() == Token::EQUAL) {
         // Make a nicer error message for normal var sets.
         *err = Err(binary->left()->GetRange(), "Assignment had no effect.",
                    help);
       } else {
         // This will happen for internally-generated variables.
@@ skipping 40 matching lines @@
             "Which would clobber the one in your current scope"));
         err->AppendSubErr(Err(*existing_value, "defined here.",
             "Executing " + desc_string + " should not conflict with anything "
             "in the current\nscope unless the values are identical."));
         return false;
       }
     }
     dest->values_[current_name] = pair.second;
 
     if (options.mark_dest_used)
-      dest->MarkUsed(current_name);
+      dest->MarkUsed(current_name, err);
   }
 
   // Target defaults are owning pointers.
   for (const auto& pair : target_defaults_) {
     const std::string& current_name = pair.first;
     if (!options.excluded_values.empty() &&
         options.excluded_values.find(current_name) !=
             options.excluded_values.end()) {
       continue;  // Skip the excluded value.
     }
@@ skipping 224 matching lines @@
     return false;
   for (const auto& pair : a) {
     const auto& found_b = b.find(pair.first);
     if (found_b == b.end())
       return false;  // Item in 'a' but not 'b'.
     if (pair.second.value != found_b->second.value)
       return false;  // Values for variable in 'a' and 'b' are different.
   }
   return true;
 }