Fix help and error messages.

tools/gn/operators.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/operators.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "tools/gn/err.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scope.h"
@@ skipping 275 matching lines @@
 
     // Left-hand-side list.
     case Value::LIST:
       RemoveMatchesFromList(op_node, left, right, err);
       return;
 
     default:
       break;
   }
 
-  *err = Err(op_node->op(), "Incompatible types to add.",
+  *err = Err(op_node->op(), "Incompatible types to subtract.",
       std::string("I see a ") + Value::DescribeType(left->type()) + " and a " +
       Value::DescribeType(right.type()) + ".");
 }
 
 Value ExecuteMinusEquals(Scope* scope,
                          const BinaryOpNode* op_node,
                          const Token& left,
                          const Value& right,
                          Err* err) {
   Value* left_value =
@@ skipping 200 matching lines @@
                             const ParseNode* right,
                             Err* err) {
   const Token& op = op_node->op();
 
   // First handle the ones that take an lvalue.
   if (op.type() == Token::EQUAL ||
       op.type() == Token::PLUS_EQUALS ||
       op.type() == Token::MINUS_EQUALS) {
     const IdentifierNode* left_id = left->AsIdentifier();
     if (!left_id) {
-      *err = Err(op, "Operator requires an lvalue.",
-                 "This thing on the left is not an idenfitier.");
+      *err = Err(op, "Operator requires a lvalue.",
+                 "This thing on the left is not an identifier.");
       err->AppendRange(left->GetRange());
       return Value();
     }
     const Token& dest = left_id->value();
 
     Value right_value = right->Execute(scope, err);
     if (err->has_error())
       return Value();
     if (right_value.type() == Value::NONE) {
-      *err = Err(op, "Operator requires an rvalue.",
+      *err = Err(op, "Operator requires a rvalue.",
                  "This thing on the right does not evaluate to a value.");
       err->AppendRange(right->GetRange());
       return Value();
     }
 
     if (op.type() == Token::EQUAL)
       return ExecuteEquals(scope, op_node, dest, right_value, err);
     if (op.type() == Token::PLUS_EQUALS)
       return ExecutePlusEquals(scope, op_node, dest, right_value, err);
     if (op.type() == Token::MINUS_EQUALS)
       return ExecuteMinusEquals(scope, op_node, dest, right_value, err);
     NOTREACHED();
     return Value();
   }
 
   // Left value.
   Value left_value = left->Execute(scope, err);
   if (err->has_error())
     return Value();
   if (left_value.type() == Value::NONE) {
-    *err = Err(op, "Operator requires an value.",
+    *err = Err(op, "Operator requires a value.",
                "This thing on the left does not evaluate to a value.");
     err->AppendRange(left->GetRange());
     return Value();
   }
 
   // Right value. Note: don't move this above to share code with the lvalue
   // version since in this case we want to execute the left side first.
   Value right_value = right->Execute(scope, err);
   if (err->has_error())
     return Value();
   if (right_value.type() == Value::NONE) {
-    *err = Err(op, "Operator requires an value.",
+    *err = Err(op, "Operator requires a value.",
                "This thing on the right does not evaluate to a value.");
     err->AppendRange(right->GetRange());
     return Value();
   }
 
   // +, -.
   if (op.type() == Token::MINUS)
     return ExecuteMinus(scope, op_node, left_value, right_value, err);
   if (op.type() == Token::PLUS)
     return ExecutePlus(scope, op_node, left_value, right_value, err);
@@ skipping 13 matching lines @@
     return ExecuteLess(scope, op_node, left_value, right_value, err);
 
   // ||, &&.
   if (op.type() == Token::BOOLEAN_OR)
     return ExecuteOr(scope, op_node, left_value, right_value, err);
   if (op.type() == Token::BOOLEAN_AND)
     return ExecuteAnd(scope, op_node, left_value, right_value, err);
 
   return Value();
 }