Fix help and error messages.

tools/gn/args.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/args.h"
 
 #include "build/build_config.h"
 #include "tools/gn/variables.h"
 
 #if defined(OS_WIN)
@@ skipping 32 matching lines @@
     "\n"
     "How build arguments are used\n"
     "\n"
     "  If you want to use an argument, you use declare_args() and specify\n"
     "  default values. These default values will apply if none of the steps\n"
     "  listed in the \"How build arguments are set\" section above apply to\n"
     "  the given argument, but the defaults will not override any of these.\n"
     "\n"
     "  Often, the root build config file will declare global arguments that\n"
     "  will be passed to all buildfiles. Individual build files can also\n"
-    "  specify arguments that apply only to those files. It is also usedful\n"
+    "  specify arguments that apply only to those files. It is also useful\n"
     "  to specify build args in an \"import\"-ed file if you want such\n"
     "  arguments to apply to multiple buildfiles.\n";
 
 Args::Args() {
 }
 
 Args::Args(const Args& other)
     : overrides_(other.overrides_),
       all_overrides_(other.all_overrides_),
       declared_arguments_(other.declared_arguments_) {
@@ skipping 38 matching lines @@
     // seen it before. Instead, we check that the location matches. We
     // additionally check that the value matches to prevent people from
     // declaring defaults based on other parameters that may change. The
     // rationale is that you should have exactly one default value for each
     // argument that we can display in the help.
     Scope::KeyValueMap::iterator previously_declared =
         declared_arguments_.find(i->first);
     if (previously_declared != declared_arguments_.end()) {
       if (previously_declared->second.origin() != i->second.origin()) {
         // Declaration location mismatch.
-        *err = Err(i->second.origin(), "Duplicate build arg declaration.",
+        *err = Err(i->second.origin(), "Duplicate build argument declaration.",
             "Here you're declaring an argument that was already declared "
             "elsewhere.\nYou can only declare each argument once in the entire "
             "build so there is one\ncanonical place for documentation and the "
             "default value. Either move this\nargument to the build config "
             "file (for visibility everywhere) or to a .gni file\nthat you "
             "\"import\" from the files where you need it (preferred).");
         err->AppendSubErr(Err(previously_declared->second.origin(),
                               "Previous declaration.",
                               "See also \"gn help buildargs\" for more on how "
-                              "build args work."));
+                              "build arguments work."));
         return false;
       } else if (previously_declared->second != i->second) {
         // Default value mismatch.
         *err = Err(i->second.origin(),
-            "Non-constant default value for build arg.",
-            "Each build arg should have one default value so we report it "
-            "nicely in the\n\"gn args\" command. Please make this value "
+            "Non-constant default value for build argument.",
+            "Each build argument should have one default value so we report "
+            "it nicely in the\n\"gn args\" command. Please make this value "
             "constant.");
         return false;
       }
     } else {
       declared_arguments_.insert(*i);
     }
 
     // Only set on the current scope to the new value if it hasn't been already
     // set. Mark the variable used so the build script can override it in
     // certain cases without getting unused value errors.
     if (!scope_to_set->GetValue(i->first)) {
       scope_to_set->SetValue(i->first, i->second, i->second.origin());
       scope_to_set->MarkUsed(i->first);
     }
   }
 
   return true;
 }
 
 bool Args::VerifyAllOverridesUsed(Err* err) const {
   base::AutoLock lock(lock_);
 
   for (Scope::KeyValueMap::const_iterator i = all_overrides_.begin();
        i != all_overrides_.end(); ++i) {
     if (declared_arguments_.find(i->first) == declared_arguments_.end()) {
-      *err = Err(i->second.origin(), "Build arg has no effect.",
-          "The value \"" + i->first.as_string() + "\" was set a build "
+      *err = Err(i->second.origin(), "Build argument has no effect.",
+          "The variable \"" + i->first.as_string() + "\" was set as a build "
           "argument\nbut never appeared in a declare_args() block in any "
           "buildfile.");
       return false;
     }
   }
   return true;
 }
 
 void Args::SetSystemVars(Scope* dest) const {
   // Host OS.
@@ skipping 73 matching lines @@
        i != values.end(); ++i)
     scope->SetValue(i->first, i->second, i->second.origin());
 }
 
 void Args::SaveOverrideRecord(const Scope::KeyValueMap& values) const {
   base::AutoLock lock(lock_);
   for (Scope::KeyValueMap::const_iterator i = values.begin();
        i != values.end(); ++i)
     all_overrides_[i->first] = i->second;
 }