Remove usages of using namespace std;

This is mandated by the google style guide:
https://google.github.io/styleguide/cppguide.html

53 files changed, 787 insertions, 766 deletions

diff --git a/src/command.cc b/src/command.cc
index da217bc..6bed3e1 100644
--- a/src/command.cc
+++ b/src/command.cc
@@ -41,8 +41,8 @@ class AutoVar : public Var {
     return "";
   }
 
-  virtual string DebugString() const override {
-    return string("AutoVar(") + sym_ + ")";
+  virtual std::string DebugString() const override {
+    return std::string("AutoVar(") + sym_ + ")";
   }
 
   virtual bool IsFunc(Evaluator*) const override { return true; }
@@ -60,7 +60,7 @@ class AutoVar : public Var {
    public:                                                            \
     name(CommandEvaluator* ce, const char* sym) : AutoVar(ce, sym) {} \
     virtual ~name() = default;                                        \
-    virtual void Eval(Evaluator* ev, string* s) const override;       \
+    virtual void Eval(Evaluator* ev, std::string* s) const override;  \
   }
 
 DECLARE_AUTO_VAR_CLASS(AutoAtVar);
@@ -76,7 +76,7 @@ class AutoSuffixDVar : public AutoVar {
   AutoSuffixDVar(CommandEvaluator* ce, const char* sym, Var* wrapped)
       : AutoVar(ce, sym), wrapped_(wrapped) {}
   virtual ~AutoSuffixDVar() = default;
-  virtual void Eval(Evaluator* ev, string* s) const override;
+  virtual void Eval(Evaluator* ev, std::string* s) const override;
 
  private:
   Var* wrapped_;
@@ -87,24 +87,24 @@ class AutoSuffixFVar : public AutoVar {
   AutoSuffixFVar(CommandEvaluator* ce, const char* sym, Var* wrapped)
       : AutoVar(ce, sym), wrapped_(wrapped) {}
   virtual ~AutoSuffixFVar() = default;
-  virtual void Eval(Evaluator* ev, string* s) const override;
+  virtual void Eval(Evaluator* ev, std::string* s) const override;
 
  private:
   Var* wrapped_;
 };
 
-void AutoAtVar::Eval(Evaluator*, string* s) const {
+void AutoAtVar::Eval(Evaluator*, std::string* s) const {
   *s += ce_->current_dep_node()->output.str();
 }
 
-void AutoLessVar::Eval(Evaluator*, string* s) const {
+void AutoLessVar::Eval(Evaluator*, std::string* s) const {
   auto& ai = ce_->current_dep_node()->actual_inputs;
   if (!ai.empty())
     *s += ai[0].str();
 }
 
-void AutoHatVar::Eval(Evaluator*, string* s) const {
-  unordered_set<StringPiece> seen;
+void AutoHatVar::Eval(Evaluator*, std::string* s) const {
+  std::unordered_set<StringPiece> seen;
   WordWriter ww(s);
   for (Symbol ai : ce_->current_dep_node()->actual_inputs) {
     if (seen.insert(ai.str()).second)
@@ -112,14 +112,14 @@ void AutoHatVar::Eval(Evaluator*, string* s) const {
   }
 }
 
-void AutoPlusVar::Eval(Evaluator*, string* s) const {
+void AutoPlusVar::Eval(Evaluator*, std::string* s) const {
   WordWriter ww(s);
   for (Symbol ai : ce_->current_dep_node()->actual_inputs) {
     ww.Write(ai.str());
   }
 }
 
-void AutoStarVar::Eval(Evaluator*, string* s) const {
+void AutoStarVar::Eval(Evaluator*, std::string* s) const {
   const DepNode* n = ce_->current_dep_node();
   if (!n->output_pattern.IsValid())
     return;
@@ -127,15 +127,15 @@ void AutoStarVar::Eval(Evaluator*, string* s) const {
   pat.Stem(n->output.str()).AppendToString(s);
 }
 
-void AutoQuestionVar::Eval(Evaluator* ev, string* s) const {
-  unordered_set<StringPiece> seen;
+void AutoQuestionVar::Eval(Evaluator* ev, std::string* s) const {
+  std::unordered_set<StringPiece> seen;
 
   if (ev->avoid_io()) {
     // Check timestamps using the shell at the start of rule execution
     // instead.
     *s += "${KATI_NEW_INPUTS}";
     if (!ce_->found_new_inputs()) {
-      string def;
+      std::string def;
 
       WordWriter ww(&def);
       ww.Write("KATI_NEW_INPUTS=$(find");
@@ -163,12 +163,12 @@ void AutoQuestionVar::Eval(Evaluator* ev, string* s) const {
   }
 }
 
-void AutoNotImplementedVar::Eval(Evaluator* ev, string*) const {
+void AutoNotImplementedVar::Eval(Evaluator* ev, std::string*) const {
   ev->Error(StringPrintf("Automatic variable `$%s' isn't supported yet", sym_));
 }
 
-void AutoSuffixDVar::Eval(Evaluator* ev, string* s) const {
-  string buf;
+void AutoSuffixDVar::Eval(Evaluator* ev, std::string* s) const {
+  std::string buf;
   wrapped_->Eval(ev, &buf);
   WordWriter ww(s);
   for (StringPiece tok : WordScanner(buf)) {
@@ -176,8 +176,8 @@ void AutoSuffixDVar::Eval(Evaluator* ev, string* s) const {
   }
 }
 
-void AutoSuffixFVar::Eval(Evaluator* ev, string* s) const {
-  string buf;
+void AutoSuffixFVar::Eval(Evaluator* ev, std::string* s) const {
+  std::string buf;
   wrapped_->Eval(ev, &buf);
   WordWriter ww(s);
   for (StringPiece tok : WordScanner(buf)) {
@@ -232,7 +232,7 @@ std::vector<Command> CommandEvaluator::Eval(const DepNode& n) {
   found_new_inputs_ = false;
   for (Value* v : n.cmds) {
     ev_->set_loc(v->Location());
-    const string&& cmds_buf = v->Eval(ev_);
+    const std::string&& cmds_buf = v->Eval(ev_);
     StringPiece cmds = cmds_buf;
     bool global_echo = !g_flags.is_silent_mode;
     bool global_ignore_error = false;
@@ -243,7 +243,7 @@ std::vector<Command> CommandEvaluator::Eval(const DepNode& n) {
       size_t lf_cnt;
       size_t index = FindEndOfLine(cmds, 0, &lf_cnt);
       if (index == cmds.size())
-        index = string::npos;
+        index = std::string::npos;
       StringPiece cmd = TrimLeftSpace(cmds.substr(0, index));
       cmds = cmds.substr(index + 1);
 
@@ -257,7 +257,7 @@ std::vector<Command> CommandEvaluator::Eval(const DepNode& n) {
         command.echo = echo;
         command.ignore_error = ignore_error;
       }
-      if (index == string::npos)
+      if (index == std::string::npos)
         break;
     }
     continue;
@@ -265,7 +265,7 @@ std::vector<Command> CommandEvaluator::Eval(const DepNode& n) {
 
   if (!ev_->delayed_output_commands().empty()) {
     std::vector<Command> output_commands;
-    for (const string& cmd : ev_->delayed_output_commands()) {
+    for (const std::string& cmd : ev_->delayed_output_commands()) {
       Command& c = output_commands.emplace_back(n.output);
       c.cmd = cmd;
       c.echo = false;
diff --git a/src/command.h b/src/command.h
index fb1ade3..102c508 100644
--- a/src/command.h
+++ b/src/command.h
@@ -19,8 +19,6 @@
 
 #include "symtab.h"
 
-using namespace std;
-
 struct DepNode;
 class Evaluator;
 
@@ -28,7 +26,7 @@ struct Command {
   explicit Command(Symbol o)
       : output(o), echo(true), ignore_error(false), force_no_subshell(false) {}
   Symbol output;
-  string cmd;
+  std::string cmd;
   bool echo;
   bool ignore_error;
   bool force_no_subshell;
diff --git a/src/dep.cc b/src/dep.cc
index bf4c947..481711e 100644
--- a/src/dep.cc
+++ b/src/dep.cc
@@ -39,7 +39,7 @@ namespace {
 static std::vector<std::unique_ptr<DepNode>> g_dep_node_pool;
 
 static Symbol ReplaceSuffix(Symbol s, Symbol newsuf) {
-  string r;
+  std::string r;
   AppendString(StripExt(s.str()), &r);
   r += '.';
   AppendString(newsuf.str(), &r);
@@ -48,8 +48,8 @@ static Symbol ReplaceSuffix(Symbol s, Symbol newsuf) {
 
 void ApplyOutputPattern(const Rule& r,
                         Symbol output,
-                        const vector<Symbol>& inputs,
-                        vector<Symbol>* out_inputs) {
+                        const std::vector<Symbol>& inputs,
+                        std::vector<Symbol>* out_inputs) {
   if (inputs.empty())
     return;
   if (r.is_suffix_rule) {
@@ -65,7 +65,7 @@ void ApplyOutputPattern(const Rule& r,
   CHECK(r.output_patterns.size() == 1);
   Pattern pat(r.output_patterns[0].str());
   for (Symbol input : inputs) {
-    string buf;
+    std::string buf;
     pat.AppendSubst(output.str(), input.str(), &buf);
     out_inputs->push_back(Intern(buf));
   }
@@ -98,7 +98,7 @@ class RuleTrie {
     p.first->second->Add(name.substr(1), rule);
   }
 
-  void Get(StringPiece name, vector<const Rule*>* rules) const {
+  void Get(StringPiece name, std::vector<const Rule*>* rules) const {
     for (const Entry& ent : rules_) {
       if ((ent.suffix.empty() && name.empty()) ||
           HasSuffix(name, ent.suffix.substr(1))) {
@@ -121,8 +121,8 @@ class RuleTrie {
   }
 
  private:
-  vector<Entry> rules_;
-  unordered_map<char, RuleTrie*> children_;
+  std::vector<Entry> rules_;
+  std::unordered_map<char, RuleTrie*> children_;
 };
 
 bool IsSuffixRule(Symbol output) {
@@ -132,18 +132,18 @@ bool IsSuffixRule(Symbol output) {
   size_t dot_index = rest.find('.');
   // If there is only a single dot or the third dot, this is not a
   // suffix rule.
-  if (dot_index == string::npos ||
-      rest.substr(dot_index + 1).find('.') != string::npos) {
+  if (dot_index == std::string::npos ||
+      rest.substr(dot_index + 1).find('.') != std::string::npos) {
     return false;
   }
   return true;
 }
 
 struct RuleMerger {
-  vector<const Rule*> rules;
-  vector<pair<Symbol, RuleMerger*>> implicit_outputs;
-  vector<Symbol> symlink_outputs;
-  vector<Symbol> validations;
+  std::vector<const Rule*> rules;
+  std::vector<std::pair<Symbol, RuleMerger*>> implicit_outputs;
+  std::vector<Symbol> symlink_outputs;
+  std::vector<Symbol> validations;
   const Rule* primary_rule;
   const RuleMerger* parent;
   Symbol parent_sym;
@@ -153,7 +153,7 @@ struct RuleMerger {
       : primary_rule(nullptr), parent(nullptr), is_double_colon(false) {}
 
   void AddImplicitOutput(Symbol output, RuleMerger* merger) {
-    implicit_outputs.push_back(make_pair(output, merger));
+    implicit_outputs.push_back(std::make_pair(output, merger));
   }
 
   void AddSymlinkOutput(Symbol output) { symlink_outputs.push_back(output); }
@@ -292,8 +292,8 @@ DepNode::DepNode(Symbol o, bool p, bool r)
 class DepBuilder {
  public:
   DepBuilder(Evaluator* ev,
-             const vector<const Rule*>& rules,
-             const unordered_map<Symbol, Vars*>& rule_vars)
+             const std::vector<const Rule*>& rules,
+             const std::unordered_map<Symbol, Vars*>& rule_vars)
       : ev_(ev),
         rule_vars_(rule_vars),
         implicit_rules_(new RuleTrie()),
@@ -315,7 +315,7 @@ class DepBuilder {
 
   void HandleSpecialTargets() {
     Loc loc;
-    vector<Symbol> targets;
+    std::vector<Symbol> targets;
 
     if (GetRuleInputs(Intern(".PHONY"), &targets, &loc)) {
       for (Symbol t : targets)
@@ -355,7 +355,7 @@ class DepBuilder {
 
   ~DepBuilder() {}
 
-  void Build(vector<Symbol> targets, vector<NamedDepNode>* nodes) {
+  void Build(std::vector<Symbol> targets, std::vector<NamedDepNode>* nodes) {
     if (!first_rule_.IsValid()) {
       ERROR("*** No targets.");
     }
@@ -402,7 +402,7 @@ class DepBuilder {
            ::Exists(target.str());
   }
 
-  bool GetRuleInputs(Symbol s, vector<Symbol>* o, Loc* l) {
+  bool GetRuleInputs(Symbol s, std::vector<Symbol>* o, Loc* l) {
     auto found = rules_.find(s);
     if (found == rules_.end())
       return false;
@@ -417,7 +417,7 @@ class DepBuilder {
     return true;
   }
 
-  void PopulateRules(const vector<const Rule*>& rules) {
+  void PopulateRules(const std::vector<const Rule*>& rules) {
     for (const Rule* rule : rules) {
       if (rule->outputs.empty()) {
         PopulateImplicitRule(rule);
@@ -435,7 +435,7 @@ class DepBuilder {
       }
       auto var = vars->Lookup(implicit_outputs_var_name_);
       if (var->IsDefined()) {
-        string implicit_outputs;
+        std::string implicit_outputs;
         var->Eval(ev_, &implicit_outputs);
 
         for (StringPiece output : WordScanner(implicit_outputs)) {
@@ -447,7 +447,7 @@ class DepBuilder {
 
       var = vars->Lookup(validations_var_name_);
       if (var->IsDefined()) {
-        string validations;
+        std::string validations;
         var->Eval(ev_, &validations);
 
         for (StringPiece validation : WordScanner(validations)) {
@@ -458,7 +458,7 @@ class DepBuilder {
 
       var = vars->Lookup(symlink_outputs_var_name_);
       if (var->IsDefined()) {
-        string symlink_outputs;
+        std::string symlink_outputs;
         var->Eval(ev_, &symlink_outputs);
 
         for (StringPiece output : WordScanner(symlink_outputs)) {
@@ -485,7 +485,7 @@ class DepBuilder {
 
     StringPiece input_suffix = rest.substr(0, dot_index);
     StringPiece output_suffix = rest.substr(dot_index + 1);
-    shared_ptr<Rule> r = make_shared<Rule>(*rule);
+    std::shared_ptr<Rule> r = std::make_shared<Rule>(*rule);
     r->inputs.clear();
     r->inputs.push_back(Intern(input_suffix));
     r->is_suffix_rule = true;
@@ -512,7 +512,7 @@ class DepBuilder {
       return false;
     if (!rule->cmds.empty())
       return false;
-    const string& i = rule->inputs[0].str();
+    const std::string& i = rule->inputs[0].str();
     return (i == "RCS/%,v" || i == "RCS/%" || i == "%,v" || i == "s.%" ||
             i == "SCCS/s.%");
   }
@@ -551,14 +551,14 @@ class DepBuilder {
   bool CanPickImplicitRule(const Rule* rule,
                            Symbol output,
                            DepNode* n,
-                           shared_ptr<Rule>* out_rule) {
+                           std::shared_ptr<Rule>* out_rule) {
     Symbol matched;
     for (Symbol output_pattern : rule->output_patterns) {
       Pattern pat(output_pattern.str());
       if (pat.Match(output.str())) {
         bool ok = true;
         for (Symbol input : rule->inputs) {
-          string buf;
+          std::string buf;
           pat.AppendSubst(output.str(), input.str(), &buf);
           if (!Exists(Intern(buf))) {
             ok = false;
@@ -575,14 +575,14 @@ class DepBuilder {
     if (!matched.IsValid())
       return false;
 
-    *out_rule = make_shared<Rule>(*rule);
+    *out_rule = std::make_shared<Rule>(*rule);
     if ((*out_rule)->output_patterns.size() > 1) {
       // We should mark all other output patterns as used.
       Pattern pat(matched.str());
       for (Symbol output_pattern : rule->output_patterns) {
         if (output_pattern == matched)
           continue;
-        string buf;
+        std::string buf;
         pat.AppendSubst(output.str(), output_pattern.str(), &buf);
         done_[Intern(buf)] = n;
       }
@@ -610,7 +610,7 @@ class DepBuilder {
   bool PickRule(Symbol output,
                 DepNode* n,
                 const RuleMerger** out_rule_merger,
-                shared_ptr<Rule>* pattern_rule,
+                std::shared_ptr<Rule>* pattern_rule,
                 Vars** out_var) {
     const RuleMerger* rule_merger = LookupRuleMerger(output);
     Vars* vars = LookupRuleVars(output);
@@ -624,7 +624,7 @@ class DepBuilder {
       return true;
     }
 
-    vector<const Rule*> irules;
+    std::vector<const Rule*> irules;
     implicit_rules_->Get(output.str(), &irules);
     for (auto iter = irules.rbegin(); iter != irules.rend(); ++iter) {
       if (!CanPickImplicitRule(*iter, output, n, pattern_rule))
@@ -647,7 +647,7 @@ class DepBuilder {
     if (found == suffix_rules_.end())
       return rule_merger != nullptr;
 
-    for (const shared_ptr<Rule>& irule : found->second) {
+    for (const std::shared_ptr<Rule>& irule : found->second) {
       CHECK(irule->inputs.size() == 1);
       Symbol input = ReplaceSuffix(output, irule->inputs[0]);
       if (!Exists(input))
@@ -683,7 +683,7 @@ class DepBuilder {
     done_[output] = n;
 
     const RuleMerger* rule_merger = nullptr;
-    shared_ptr<Rule> pattern_rule;
+    std::shared_ptr<Rule> pattern_rule;
     Vars* vars;
     if (!PickRule(output, n, &rule_merger, &pattern_rule, &vars)) {
       return n;
@@ -702,7 +702,7 @@ class DepBuilder {
     else
       RuleMerger().FillDepNode(output, pattern_rule.get(), n);
 
-    vector<unique_ptr<ScopedVar>> sv;
+    std::vector<std::unique_ptr<ScopedVar>> sv;
     ScopedFrame frame(ev_->Enter(FrameType::DEPENDENCY, output.str(), n->loc));
 
     if (vars) {
@@ -715,7 +715,7 @@ class DepBuilder {
           Var* old_var = ev_->LookupVar(name);
           if (old_var->IsDefined()) {
             // TODO: This would be incorrect and has a leak.
-            shared_ptr<string> s = make_shared<string>();
+            std::shared_ptr<std::string> s = std::make_shared<std::string>();
             old_var->Eval(ev_, s.get());
             if (!s->empty())
               *s += ' ';
@@ -743,7 +743,7 @@ class DepBuilder {
     }
 
     if (g_flags.warn_phony_looks_real && n->is_phony &&
-        output.str().find('/') != string::npos) {
+        output.str().find('/') != std::string::npos) {
       if (g_flags.werror_phony_looks_real) {
         ERROR_LOC(
             n->loc,
@@ -780,7 +780,7 @@ class DepBuilder {
       done_[output] = n;
 
       if (g_flags.warn_phony_looks_real && n->is_phony &&
-          output.str().find('/') != string::npos) {
+          output.str().find('/') != std::string::npos) {
         if (g_flags.werror_phony_looks_real) {
           ERROR_LOC(n->loc,
                     "*** PHONY target \"%s\" looks like a real file (contains "
@@ -820,7 +820,7 @@ class DepBuilder {
 
       bool is_phony = c->is_phony;
       if (!is_phony && !c->has_rule && g_flags.top_level_phony) {
-        is_phony = input.str().find('/') == string::npos;
+        is_phony = input.str().find('/') == std::string::npos;
       }
       if (!n->is_phony && is_phony) {
         if (g_flags.werror_real_to_phony) {
@@ -923,16 +923,17 @@ class DepBuilder {
       return lhs.str() < rhs.str();
     }
   };
-  map<Symbol, RuleMerger, TargetComp> rules_;
-  const unordered_map<Symbol, Vars*>& rule_vars_;
-  unique_ptr<Vars> cur_rule_vars_;
+  std::map<Symbol, RuleMerger, TargetComp> rules_;
+  const std::unordered_map<Symbol, Vars*>& rule_vars_;
+  std::unique_ptr<Vars> cur_rule_vars_;
 
-  unique_ptr<RuleTrie> implicit_rules_;
-  typedef unordered_map<StringPiece, vector<shared_ptr<Rule>>> SuffixRuleMap;
+  std::unique_ptr<RuleTrie> implicit_rules_;
+  typedef std::unordered_map<StringPiece, std::vector<std::shared_ptr<Rule>>>
+      SuffixRuleMap;
   SuffixRuleMap suffix_rules_;
 
   Symbol first_rule_;
-  unordered_map<Symbol, DepNode*> done_;
+  std::unordered_map<Symbol, DepNode*> done_;
   SymbolSet phony_;
   SymbolSet restat_;
   Symbol depfile_var_name_;
@@ -943,10 +944,10 @@ class DepBuilder {
 };
 
 void MakeDep(Evaluator* ev,
-             const vector<const Rule*>& rules,
-             const unordered_map<Symbol, Vars*>& rule_vars,
-             const vector<Symbol>& targets,
-             vector<NamedDepNode>* nodes) {
+             const std::vector<const Rule*>& rules,
+             const std::unordered_map<Symbol, Vars*>& rule_vars,
+             const std::vector<Symbol>& targets,
+             std::vector<NamedDepNode>* nodes) {
   DepBuilder db(ev, rules, rule_vars);
   ScopedTimeReporter tr("make dep (build)");
   db.Build(targets, nodes);
diff --git a/src/dep.h b/src/dep.h
index fc1d855..aff8d94 100644
--- a/src/dep.h
+++ b/src/dep.h
@@ -30,26 +30,26 @@ class Var;
 class Vars;
 class Frame;
 
-typedef pair<Symbol, struct DepNode*> NamedDepNode;
+typedef std::pair<Symbol, struct DepNode*> NamedDepNode;
 
 struct DepNode {
   DepNode(Symbol output, bool is_phony, bool is_restat);
-  string DebugString();
+  std::string DebugString();
 
   Symbol output;
-  vector<Value*> cmds;
-  vector<NamedDepNode> deps;
-  vector<NamedDepNode> order_onlys;
-  vector<NamedDepNode> validations;
+  std::vector<Value*> cmds;
+  std::vector<NamedDepNode> deps;
+  std::vector<NamedDepNode> order_onlys;
+  std::vector<NamedDepNode> validations;
   bool has_rule;
   bool is_default_target;
   bool is_phony;
   bool is_restat;
-  vector<Symbol> implicit_outputs;
-  vector<Symbol> symlink_outputs;
-  vector<Symbol> actual_inputs;
-  vector<Symbol> actual_order_only_inputs;
-  vector<Symbol> actual_validations;
+  std::vector<Symbol> implicit_outputs;
+  std::vector<Symbol> symlink_outputs;
+  std::vector<Symbol> actual_inputs;
+  std::vector<Symbol> actual_order_only_inputs;
+  std::vector<Symbol> actual_validations;
   Vars* rule_vars;
   Var* depfile_var;
   Var* ninja_pool_var;
@@ -58,10 +58,10 @@ struct DepNode {
 };
 
 void MakeDep(Evaluator* ev,
-             const vector<const Rule*>& rules,
-             const unordered_map<Symbol, Vars*>& rule_vars,
-             const vector<Symbol>& targets,
-             vector<NamedDepNode>* nodes);
+             const std::vector<const Rule*>& rules,
+             const std::unordered_map<Symbol, Vars*>& rule_vars,
+             const std::vector<Symbol>& targets,
+             std::vector<NamedDepNode>* nodes);
 
 bool IsSpecialTarget(Symbol output);
 
diff --git a/src/eval.cc b/src/eval.cc
index 637f373..7dad261 100644
--- a/src/eval.cc
+++ b/src/eval.cc
@@ -315,7 +315,7 @@ void Evaluator::EvalAssign(const AssignStmt* stmt) {
     Error("*** empty variable name.");
 
   if (lhs == kKatiReadonlySym) {
-    string rhs;
+    std::string rhs;
     stmt->rhs->Eval(this, &rhs);
     for (auto const& name : WordScanner(rhs)) {
       Var* var = Intern(name).GetGlobalVar();
@@ -354,10 +354,10 @@ void Evaluator::EvalAssign(const AssignStmt* stmt) {
 // Returns the remainder of <before_term>.
 static StringPiece ParseRuleTargets(const Loc& loc,
                                     const StringPiece& before_term,
-                                    vector<Symbol>* targets,
+                                    std::vector<Symbol>* targets,
                                     bool* is_pattern_rule) {
   size_t pos = before_term.find(':');
-  if (pos == string::npos) {
+  if (pos == std::string::npos) {
     ERROR_LOC(loc, "*** missing separator.");
   }
   StringPiece targets_string = before_term.substr(0, pos);
@@ -378,7 +378,7 @@ static StringPiece ParseRuleTargets(const Loc& loc,
 }
 
 // Strip leading spaces and trailing spaces and colons.
-static string FormatRuleError(const string& before_term) {
+static std::string FormatRuleError(const std::string& before_term) {
   if (before_term.size() == 0) {
     return before_term;
   }
@@ -396,7 +396,7 @@ static string FormatRuleError(const string& before_term) {
 }
 
 void Evaluator::MarkVarsReadonly(Value* vars_list) {
-  string vars_list_string;
+  std::string vars_list_string;
   vars_list->Eval(this, &vars_list_string);
   for (auto const& name : WordScanner(vars_list_string)) {
     Var* var = current_scope_->Lookup(Intern(name));
@@ -407,7 +407,7 @@ void Evaluator::MarkVarsReadonly(Value* vars_list) {
   }
 }
 
-void Evaluator::EvalRuleSpecificAssign(const vector<Symbol>& targets,
+void Evaluator::EvalRuleSpecificAssign(const std::vector<Symbol>& targets,
                                        const RuleStmt* stmt,
                                        const StringPiece& after_targets,
                                        size_t separator_pos) {
@@ -463,15 +463,15 @@ void Evaluator::EvalRule(const RuleStmt* stmt) {
   loc_ = stmt->loc();
   last_rule_ = NULL;
 
-  const string&& before_term = stmt->lhs->Eval(this);
+  const std::string&& before_term = stmt->lhs->Eval(this);
   // See semicolon.mk.
-  if (before_term.find_first_not_of(" \t\n;") == string::npos) {
+  if (before_term.find_first_not_of(" \t\n;") == std::string::npos) {
     if (stmt->sep == RuleStmt::SEP_SEMICOLON)
       Error("*** missing rule before commands.");
     return;
   }
 
-  vector<Symbol> targets;
+  std::vector<Symbol> targets;
   bool is_pattern_rule;
   StringPiece after_targets =
       ParseRuleTargets(loc_, before_term, &targets, &is_pattern_rule);
@@ -486,9 +486,9 @@ void Evaluator::EvalRule(const RuleStmt* stmt) {
   // first assignment token.
   size_t separator_pos = after_targets.find_first_of("=;");
   char separator = '\0';
-  if (separator_pos != string::npos) {
+  if (separator_pos != std::string::npos) {
     separator = after_targets[separator_pos];
-  } else if (separator_pos == string::npos &&
+  } else if (separator_pos == std::string::npos &&
              (stmt->sep == RuleStmt::SEP_EQ ||
               stmt->sep == RuleStmt::SEP_FINALEQ)) {
     separator_pos = after_targets.size();
@@ -550,7 +550,7 @@ void Evaluator::EvalCommand(const CommandStmt* stmt) {
   loc_ = stmt->loc();
 
   if (!last_rule_) {
-    vector<Stmt*> stmts;
+    std::vector<Stmt*> stmts;
     ParseNotAfterRule(stmt->orig, stmt->loc(), &stmts);
     for (Stmt* a : stmts)
       a->Eval(this);
@@ -570,7 +570,7 @@ void Evaluator::EvalIf(const IfStmt* stmt) {
   switch (stmt->op) {
     case CondOp::IFDEF:
     case CondOp::IFNDEF: {
-      string var_name;
+      std::string var_name;
       stmt->lhs->Eval(this, &var_name);
       Symbol lhs = Intern(TrimRightSpace(var_name));
       if (const auto& s = lhs.str();
@@ -584,8 +584,8 @@ void Evaluator::EvalIf(const IfStmt* stmt) {
     }
     case CondOp::IFEQ:
     case CondOp::IFNEQ: {
-      const string&& lhs = stmt->lhs->Eval(this);
-      const string&& rhs = stmt->rhs->Eval(this);
+      const std::string&& lhs = stmt->lhs->Eval(this);
+      const std::string&& rhs = stmt->rhs->Eval(this);
       is_true = ((lhs == rhs) == (stmt->op == CondOp::IFEQ));
       break;
     }
@@ -594,7 +594,7 @@ void Evaluator::EvalIf(const IfStmt* stmt) {
       abort();
   }
 
-  const vector<Stmt*>* stmts;
+  const std::vector<Stmt*>* stmts;
   if (is_true) {
     stmts = &stmt->true_stmts;
   } else {
@@ -606,7 +606,7 @@ void Evaluator::EvalIf(const IfStmt* stmt) {
   }
 }
 
-void Evaluator::DoInclude(const string& fname) {
+void Evaluator::DoInclude(const std::string& fname) {
   CheckStack();
   COLLECT_STATS_WITH_SLOW_REPORT("included makefiles", fname.c_str());
 
@@ -633,7 +633,7 @@ void Evaluator::EvalInclude(const IncludeStmt* stmt) {
   loc_ = stmt->loc();
   last_rule_ = NULL;
 
-  const string&& pats = stmt->expr->Eval(this);
+  const std::string&& pats = stmt->expr->Eval(this);
   for (StringPiece pat : WordScanner(pats)) {
     ScopedTerminator st(pat);
     const auto& files = Glob(pat.data());
@@ -647,7 +647,7 @@ void Evaluator::EvalInclude(const IncludeStmt* stmt) {
 
     include_stack_.push_back(stmt->loc());
 
-    for (const string& fname : files) {
+    for (const std::string& fname : files) {
       if (!stmt->should_exist && g_flags.ignore_optional_include_pattern &&
           Pattern(g_flags.ignore_optional_include_pattern).Match(fname)) {
         continue;
@@ -666,11 +666,11 @@ void Evaluator::EvalExport(const ExportStmt* stmt) {
   loc_ = stmt->loc();
   last_rule_ = NULL;
 
-  const string&& exports = stmt->expr->Eval(this);
+  const std::string&& exports = stmt->expr->Eval(this);
   for (StringPiece tok : WordScanner(exports)) {
     size_t equal_index = tok.find('=');
     StringPiece lhs;
-    if (equal_index == string::npos) {
+    if (equal_index == std::string::npos) {
       lhs = tok;
     } else if (equal_index == 0 ||
                (equal_index == 1 &&
@@ -842,12 +842,12 @@ Var* Evaluator::PeekVarInCurrentScope(Symbol name) {
   return result;
 }
 
-string Evaluator::EvalVar(Symbol name) {
+std::string Evaluator::EvalVar(Symbol name) {
   return LookupVar(name)->Eval(this);
 }
 
 ScopedFrame Evaluator::Enter(FrameType frame_type,
-                             const string& name,
+                             const std::string& name,
                              Loc loc) {
   if (!trace_) {
     return ScopedFrame(this, nullptr);
@@ -857,24 +857,24 @@ ScopedFrame Evaluator::Enter(FrameType frame_type,
   return ScopedFrame(this, frame);
 }
 
-string Evaluator::GetShell() {
+std::string Evaluator::GetShell() {
   return EvalVar(kShellSym);
 }
 
-string Evaluator::GetShellFlag() {
+std::string Evaluator::GetShellFlag() {
   // TODO: Handle $(.SHELLFLAGS)
   return is_posix_ ? "-ec" : "-c";
 }
 
-string Evaluator::GetShellAndFlag() {
-  string shell = GetShell();
+std::string Evaluator::GetShellAndFlag() {
+  std::string shell = GetShell();
   shell += ' ';
   shell += GetShellFlag();
   return shell;
 }
 
 RulesAllowed Evaluator::GetAllowRules() {
-  string val = EvalVar(kAllowRulesSym);
+  std::string val = EvalVar(kAllowRulesSym);
   if (val == "warning") {
     return RULES_WARNING;
   } else if (val == "error") {
@@ -890,7 +890,7 @@ void Evaluator::PrintIncludeStack() {
   }
 }
 
-void Evaluator::Error(const string& msg) {
+void Evaluator::Error(const std::string& msg) {
   PrintIncludeStack();
   ERROR_LOC(loc_, "%s", msg.c_str());
 }
@@ -901,7 +901,7 @@ void Evaluator::DumpStackStats() const {
            LOCF(lowest_loc_));
 }
 
-void Evaluator::DumpIncludeJSON(const string& filename) const {
+void Evaluator::DumpIncludeJSON(const std::string& filename) const {
   IncludeGraph graph;
   graph.MergeTreeNode(stack_.front());
   FILE* jsonfile;
diff --git a/src/eval.h b/src/eval.h
index fc7fcff..03370ec 100644
--- a/src/eval.h
+++ b/src/eval.h
@@ -27,8 +27,6 @@
 #include "string_piece.h"
 #include "symtab.h"
 
-using namespace std;
-
 class Makefile;
 class Rule;
 class Var;
@@ -59,7 +57,7 @@ class Frame {
 
   FrameType Type() const { return type_; }
   Frame* Parent() const { return parent_; }
-  const string& Name() const { return name_; }
+  const std::string& Name() const { return name_; }
   const Loc& Location() const { return location_; }
   const std::vector<std::unique_ptr<Frame>>& Children() const {
     return children_;
@@ -144,17 +142,19 @@ class Evaluator {
   // Equivalent to LookupVar, but doesn't mark as used.
   Var* PeekVar(Symbol name);
 
-  string EvalVar(Symbol name);
+  std::string EvalVar(Symbol name);
 
   const Loc& loc() const { return loc_; }
   void set_loc(const Loc& loc) { loc_ = loc; }
 
-  const vector<const Rule*>& rules() const { return rules_; }
-  const unordered_map<Symbol, Vars*>& rule_vars() const { return rule_vars_; }
-  const unordered_map<Symbol, bool>& exports() const { return exports_; }
+  const std::vector<const Rule*>& rules() const { return rules_; }
+  const std::unordered_map<Symbol, Vars*>& rule_vars() const {
+    return rule_vars_;
+  }
+  const std::unordered_map<Symbol, bool>& exports() const { return exports_; }
 
   void PrintIncludeStack();
-  void Error(const string& msg);
+  void Error(const std::string& msg);
 
   void in_bootstrap();
   void in_command_line();
@@ -165,10 +165,10 @@ class Evaluator {
   bool avoid_io() const { return avoid_io_; }
   void set_avoid_io(bool a) { avoid_io_ = a; }
 
-  const vector<string>& delayed_output_commands() const {
+  const std::vector<std::string>& delayed_output_commands() const {
     return delayed_output_commands_;
   }
-  void add_delayed_output_command(const string& c) {
+  void add_delayed_output_command(const std::string& c) {
     delayed_output_commands_.push_back(c);
   }
   void clear_delayed_output_commands() { delayed_output_commands_.clear(); }
@@ -179,14 +179,14 @@ class Evaluator {
   void IncrementEvalDepth() { eval_depth_++; }
   void DecrementEvalDepth() { eval_depth_--; }
 
-  ScopedFrame Enter(FrameType frame_type, const string& name, Loc loc);
+  ScopedFrame Enter(FrameType frame_type, const std::string& name, Loc loc);
   Frame* CurrentFrame() const {
     return stack_.empty() ? nullptr : stack_.back();
   };
 
-  string GetShell();
-  string GetShellFlag();
-  string GetShellAndFlag();
+  std::string GetShell();
+  std::string GetShellFlag();
+  std::string GetShellAndFlag();
 
   // Parse the current value of .KATI_ALLOW_RULES
   RulesAllowed GetAllowRules();
@@ -200,15 +200,15 @@ class Evaluator {
   }
 
   void DumpStackStats() const;
-  void DumpIncludeJSON(const string& filename) const;
+  void DumpIncludeJSON(const std::string& filename) const;
 
   bool ExportDeprecated() const { return export_message_ && !export_error_; };
   bool ExportObsolete() const { return export_error_; };
   void SetExportDeprecated(StringPiece msg) {
-    export_message_.reset(new string(msg.as_string()));
+    export_message_.reset(new std::string(msg.as_string()));
   }
   void SetExportObsolete(StringPiece msg) {
-    export_message_.reset(new string(msg.as_string()));
+    export_message_.reset(new std::string(msg.as_string()));
     export_error_ = true;
   }
 
@@ -226,7 +226,7 @@ class Evaluator {
                AssignOp op,
                bool is_override,
                bool* needs_assign);
-  void DoInclude(const string& fname);
+  void DoInclude(const std::string& fname);
 
   bool IsTraced(Symbol& name) const;
   void TraceVariableLookup(const char* operation, Symbol& name, Var* var);
@@ -238,14 +238,14 @@ class Evaluator {
 
   void MarkVarsReadonly(Value* var_list);
 
-  void EvalRuleSpecificAssign(const vector<Symbol>& targets,
+  void EvalRuleSpecificAssign(const std::vector<Symbol>& targets,
                               const RuleStmt* stmt,
                               const StringPiece& lhs_string,
                               size_t separator_pos);
 
-  unordered_map<Symbol, Vars*> rule_vars_;
-  vector<const Rule*> rules_;
-  unordered_map<Symbol, bool> exports_;
+  std::unordered_map<Symbol, Vars*> rule_vars_;
+  std::vector<const Rule*> rules_;
+  std::unordered_map<Symbol, bool> exports_;
   std::set<Symbol> symbols_for_eval_;
 
   Rule* last_rule_;
@@ -269,7 +269,7 @@ class Evaluator {
   int eval_depth_;
   // Commands which should run at ninja-time (i.e., info, warning, and
   // error).
-  vector<string> delayed_output_commands_;
+  std::vector<std::string> delayed_output_commands_;
 
   Symbol posix_sym_;
   bool is_posix_;
@@ -279,10 +279,10 @@ class Evaluator {
   void* lowest_stack_;
   Loc lowest_loc_;
 
-  unique_ptr<string> export_message_;
+  std::unique_ptr<std::string> export_message_;
   bool export_error_;
 
-  vector<string> profiled_files_;
+  std::vector<std::string> profiled_files_;
 
   static SymbolSet used_undefined_vars_;
 
diff --git a/src/exec.cc b/src/exec.cc
index 40f37dc..be82593 100644
--- a/src/exec.cc
+++ b/src/exec.cc
@@ -105,7 +105,7 @@ class Executor {
         fflush(stdout);
       }
       if (!g_flags.is_dry_run) {
-        string out;
+        std::string out;
         int result = RunCommand(shell_, shellflag_, command.cmd.c_str(),
                                 RedirectStderr::STDOUT, &out);
         printf("%s", out.c_str());
@@ -130,15 +130,15 @@ class Executor {
 
  private:
   CommandEvaluator ce_;
-  unordered_map<Symbol, double> done_;
-  string shell_;
-  string shellflag_;
+  std::unordered_map<Symbol, double> done_;
+  std::string shell_;
+  std::string shellflag_;
   uint64_t num_commands_;
 };
 
 }  // namespace
 
-void Exec(const vector<NamedDepNode>& roots, Evaluator* ev) {
+void Exec(const std::vector<NamedDepNode>& roots, Evaluator* ev) {
   Executor executor(ev);
   for (auto const& root : roots) {
     executor.ExecNode(*root.second, nullptr);
diff --git a/src/exec.h b/src/exec.h
index 34fda96..3b74ba4 100644
--- a/src/exec.h
+++ b/src/exec.h
@@ -17,10 +17,9 @@
 
 #include <vector>
 
-using namespace std;
 #include "dep.h"
 class Evaluator;
 
-void Exec(const vector<NamedDepNode>& roots, Evaluator* ev);
+void Exec(const std::vector<NamedDepNode>& roots, Evaluator* ev);
 
 #endif  // EXEC_H_
diff --git a/src/expr.cc b/src/expr.cc
index 40e7b7d..a3fdf62 100644
--- a/src/expr.cc
+++ b/src/expr.cc
@@ -29,8 +29,8 @@ Evaluable::Evaluable(const Loc& loc) : loc_(loc) {}
 
 Evaluable::~Evaluable() {}
 
-string Evaluable::Eval(Evaluator* ev) const {
-  string s;
+std::string Evaluable::Eval(Evaluator* ev) const {
+  std::string s;
   Eval(ev, &s);
   return s;
 }
@@ -39,7 +39,7 @@ Value::Value(const Loc& loc) : Evaluable(loc) {}
 
 Value::~Value() {}
 
-string Value::DebugString(const Value* v) {
+std::string Value::DebugString(const Value* v) {
   return v ? NoLineBreak(v->DebugString_()) : "(null)";
 }
 
@@ -51,7 +51,7 @@ class Literal : public Value {
 
   virtual bool IsFunc(Evaluator*) const override { return false; }
 
-  virtual void Eval(Evaluator* ev, string* s) const override {
+  virtual void Eval(Evaluator* ev, std::string* s) const override {
     ev->CheckStack();
     s->append(s_.begin(), s_.end());
   }
@@ -59,7 +59,7 @@ class Literal : public Value {
   virtual bool IsLiteral() const override { return true; }
   virtual StringPiece GetLiteralValueUnsafe() const override { return s_; }
 
-  virtual string DebugString_() const override { return s_.as_string(); }
+  virtual std::string DebugString_() const override { return s_.as_string(); }
 
  private:
   StringPiece s_;
@@ -82,7 +82,7 @@ class ValueList : public Value {
     vals_.push_back(v2);
   }
 
-  ValueList(const Loc& loc, vector<Value*>* values) : ValueList(loc) {
+  ValueList(const Loc& loc, std::vector<Value*>* values) : ValueList(loc) {
     values->shrink_to_fit();
     values->swap(vals_);
   }
@@ -102,15 +102,15 @@ class ValueList : public Value {
     return false;
   }
 
-  virtual void Eval(Evaluator* ev, string* s) const override {
+  virtual void Eval(Evaluator* ev, std::string* s) const override {
     ev->CheckStack();
     for (Value* v : vals_) {
       v->Eval(ev, s);
     }
   }
 
-  virtual string DebugString_() const override {
-    string r;
+  virtual std::string DebugString_() const override {
+    std::string r;
     for (Value* v : vals_) {
       if (r.empty()) {
         r += "ValueList(";
@@ -125,7 +125,7 @@ class ValueList : public Value {
   }
 
  private:
-  vector<Value*> vals_;
+  std::vector<Value*> vals_;
 };
 
 class SymRef : public Value {
@@ -141,7 +141,7 @@ class SymRef : public Value {
     return IsInteger(name_.str());
   }
 
-  virtual void Eval(Evaluator* ev, string* s) const override {
+  virtual void Eval(Evaluator* ev, std::string* s) const override {
     ev->CheckStack();
     Var* v = ev->LookupVarForEval(name_);
     v->Used(ev, name_);
@@ -149,7 +149,7 @@ class SymRef : public Value {
     ev->VarEvalComplete(name_);
   }
 
-  virtual string DebugString_() const override {
+  virtual std::string DebugString_() const override {
     return StringPrintf("SymRef(%s)", name_.c_str());
   }
 
@@ -167,10 +167,10 @@ class VarRef : public Value {
     return true;
   }
 
-  virtual void Eval(Evaluator* ev, string* s) const override {
+  virtual void Eval(Evaluator* ev, std::string* s) const override {
     ev->CheckStack();
     ev->IncrementEvalDepth();
-    const string&& name = name_->Eval(ev);
+    const std::string&& name = name_->Eval(ev);
     ev->DecrementEvalDepth();
     Symbol sym = Intern(name);
     Var* v = ev->LookupVarForEval(sym);
@@ -179,7 +179,7 @@ class VarRef : public Value {
     ev->VarEvalComplete(sym);
   }
 
-  virtual string DebugString_() const override {
+  virtual std::string DebugString_() const override {
     return StringPrintf("VarRef(%s)", Value::DebugString(name_).c_str());
   }
 
@@ -201,17 +201,17 @@ class VarSubst : public Value {
     return name_->IsFunc(ev) || pat_->IsFunc(ev) || subst_->IsFunc(ev);
   }
 
-  virtual void Eval(Evaluator* ev, string* s) const override {
+  virtual void Eval(Evaluator* ev, std::string* s) const override {
     ev->CheckStack();
     ev->IncrementEvalDepth();
-    const string&& name = name_->Eval(ev);
+    const std::string&& name = name_->Eval(ev);
     Symbol sym = Intern(name);
     Var* v = ev->LookupVar(sym);
-    const string&& pat_str = pat_->Eval(ev);
-    const string&& subst = subst_->Eval(ev);
+    const std::string&& pat_str = pat_->Eval(ev);
+    const std::string&& subst = subst_->Eval(ev);
     ev->DecrementEvalDepth();
     v->Used(ev, sym);
-    const string&& value = v->Eval(ev);
+    const std::string&& value = v->Eval(ev);
     WordWriter ww(s);
     Pattern pat(pat_str);
     for (StringPiece tok : WordScanner(value)) {
@@ -220,7 +220,7 @@ class VarSubst : public Value {
     }
   }
 
-  virtual string DebugString_() const override {
+  virtual std::string DebugString_() const override {
     return StringPrintf("VarSubst(%s:%s=%s)", Value::DebugString(name_).c_str(),
                         Value::DebugString(pat_).c_str(),
                         Value::DebugString(subst_).c_str());
@@ -243,7 +243,7 @@ class Func : public Value {
 
   virtual bool IsFunc(Evaluator*) const override { return true; }
 
-  virtual void Eval(Evaluator* ev, string* s) const override {
+  virtual void Eval(Evaluator* ev, std::string* s) const override {
     ScopedFrame frame(ev->Enter(FrameType::FUNCALL, fi_->name, Location()));
     ev->CheckStack();
     LOG("Invoke func %s(%s)", name(), JoinValues(args_, ",").c_str());
@@ -252,7 +252,7 @@ class Func : public Value {
     ev->DecrementEvalDepth();
   }
 
-  virtual string DebugString_() const override {
+  virtual std::string DebugString_() const override {
     return StringPrintf("Func(%s %s)", fi_->name,
                         JoinValues(args_, ",").c_str());
   }
@@ -267,7 +267,7 @@ class Func : public Value {
 
  private:
   const FuncInfo* fi_;
-  vector<Value*> args_;
+  std::vector<Value*> args_;
 };
 
 static char CloseParen(char c) {
@@ -311,7 +311,7 @@ Value* Value::NewExpr(const Loc& loc, Value* v1, Value* v2, Value* v3) {
   return new ValueList(loc, v1, v2, v3);
 }
 
-Value* Value::NewExpr(const Loc& loc, vector<Value*>* values) {
+Value* Value::NewExpr(const Loc& loc, std::vector<Value*>* values) {
   if (values->size() == 1) {
     Value* v = (*values)[0];
     values->clear();
@@ -427,7 +427,7 @@ Value* ParseDollar(Loc* loc, StringPiece s, size_t* index_out) {
         Symbol sym = Intern(lit->val());
         if (g_flags.enable_kati_warnings) {
           size_t found = sym.str().find_first_of(" ({");
-          if (found != string::npos) {
+          if (found != std::string::npos) {
             KATI_WARN_LOC(start_loc,
                           "*warning*: variable lookup with '%c': %.*s",
                           sym.str()[found], SPF(s));
@@ -489,7 +489,7 @@ Value* ParseDollar(Loc* loc, StringPiece s, size_t* index_out) {
     // GNU make accepts expressions like $((). See unmatched_paren*.mk
     // for detail.
     size_t found = s.find(cp);
-    if (found != string::npos) {
+    if (found != std::string::npos) {
       KATI_WARN_LOC(start_loc, "*warning*: unmatched parentheses: %.*s",
                     SPF(s));
       *index_out = s.size();
@@ -514,7 +514,7 @@ Value* ParseExprImpl(Loc* loc,
   char save_paren = 0;
   int paren_depth = 0;
   size_t i;
-  vector<Value*> list;
+  std::vector<Value*> list;
   for (i = 0; i < s.size(); i++) {
     Loc item_loc = *loc;
 
@@ -643,8 +643,8 @@ Value* ParseExpr(Loc* loc, StringPiece s, ParseExprOpt opt) {
   return ParseExprImpl(loc, s, NULL, opt, &n);
 }
 
-string JoinValues(const vector<Value*>& vals, const char* sep) {
-  vector<string> val_strs;
+std::string JoinValues(const std::vector<Value*>& vals, const char* sep) {
+  std::vector<std::string> val_strs;
   val_strs.reserve(vals.size());
   for (Value* v : vals) {
     val_strs.push_back(Value::DebugString(v));
diff --git a/src/expr.h b/src/expr.h
index a731077..f64278d 100644
--- a/src/expr.h
+++ b/src/expr.h
@@ -21,14 +21,12 @@
 #include "loc.h"
 #include "string_piece.h"
 
-using namespace std;
-
 class Evaluator;
 
 class Evaluable {
  public:
-  virtual void Eval(Evaluator* ev, string* s) const = 0;
-  string Eval(Evaluator*) const;
+  virtual void Eval(Evaluator* ev, std::string* s) const = 0;
+  std::string Eval(Evaluator*) const;
   const Loc& Location() const { return loc_; }
   // Whether this Evaluable is either knowably a function (e.g. one of the
   // built-ins) or likely to be a function-type macro (i.e. one that has
@@ -55,7 +53,7 @@ class Value : public Evaluable {
   // All NewExpr calls take ownership of the Value instances.
   static Value* NewExpr(const Loc& loc, Value* v1, Value* v2);
   static Value* NewExpr(const Loc& loc, Value* v1, Value* v2, Value* v3);
-  static Value* NewExpr(const Loc& loc, vector<Value*>* values);
+  static Value* NewExpr(const Loc& loc, std::vector<Value*>* values);
 
   static Value* NewLiteral(StringPiece s);
   virtual ~Value();
@@ -63,11 +61,11 @@ class Value : public Evaluable {
   // Only safe after IsLiteral() returns true.
   virtual StringPiece GetLiteralValueUnsafe() const { return ""; }
 
-  static string DebugString(const Value*);
+  static std::string DebugString(const Value*);
 
  protected:
   Value(const Loc& loc);
-  virtual string DebugString_() const = 0;
+  virtual std::string DebugString_() const = 0;
 };
 
 enum struct ParseExprOpt {
@@ -87,6 +85,6 @@ Value* ParseExpr(Loc* loc,
                  StringPiece s,
                  ParseExprOpt opt = ParseExprOpt::NORMAL);
 
-string JoinValues(const vector<Value*>& vals, const char* sep);
+std::string JoinValues(const std::vector<Value*>& vals, const char* sep);
 
 #endif  // EXPR_H_
diff --git a/src/file.cc b/src/file.cc
index 9ef6708..43eacbc 100644
--- a/src/file.cc
+++ b/src/file.cc
@@ -26,7 +26,7 @@
 #include "parser.h"
 #include "stmt.h"
 
-Makefile::Makefile(const string& filename)
+Makefile::Makefile(const std::string& filename)
     : mtime_(0), filename_(filename), exists_(false) {
   int fd = open(filename.c_str(), O_RDONLY);
   if (fd < 0) {
diff --git a/src/file.h b/src/file.h
index 6af6696..757d7e7 100644
--- a/src/file.h
+++ b/src/file.h
@@ -20,28 +20,26 @@
 #include <string>
 #include <vector>
 
-using namespace std;
-
 struct Stmt;
 
 class Makefile {
  public:
-  explicit Makefile(const string& filename);
+  explicit Makefile(const std::string& filename);
   ~Makefile();
 
-  const string& buf() const { return buf_; }
-  const string& filename() const { return filename_; }
+  const std::string& buf() const { return buf_; }
+  const std::string& filename() const { return filename_; }
 
-  const vector<Stmt*>& stmts() const { return stmts_; }
-  vector<Stmt*>* mutable_stmts() { return &stmts_; }
+  const std::vector<Stmt*>& stmts() const { return stmts_; }
+  std::vector<Stmt*>* mutable_stmts() { return &stmts_; }
 
   bool Exists() const { return exists_; }
 
  private:
-  string buf_;
+  std::string buf_;
   uint64_t mtime_;
-  string filename_;
-  vector<Stmt*> stmts_;
+  std::string filename_;
+  std::vector<Stmt*> stmts_;
   bool exists_;
 };
 
diff --git a/src/file_cache.cc b/src/file_cache.cc
index eb64a42..d0b4ea5 100644
--- a/src/file_cache.cc
+++ b/src/file_cache.cc
@@ -14,11 +14,10 @@
 
 // +build ignore
 
-#include "file_cache.h"
-
 #include <unordered_map>
 
 #include "file.h"
+#include "file_cache.h"
 
 MakefileCacheManager::MakefileCacheManager() = default;
 
@@ -26,7 +25,7 @@ MakefileCacheManager::~MakefileCacheManager() = default;
 
 class MakefileCacheManagerImpl : public MakefileCacheManager {
  public:
-  virtual const Makefile& ReadMakefile(const string& filename) override {
+  virtual const Makefile& ReadMakefile(const std::string& filename) override {
     auto iter = cache_.find(filename);
     if (iter != cache_.end()) {
       return iter->second;
@@ -34,13 +33,13 @@ class MakefileCacheManagerImpl : public MakefileCacheManager {
     return (cache_.emplace(filename, filename).first)->second;
   }
 
-  virtual void GetAllFilenames(unordered_set<string>* out) override {
+  virtual void GetAllFilenames(std::unordered_set<std::string>* out) override {
     for (const auto& p : cache_)
       out->insert(p.first);
   }
 
  private:
-  unordered_map<string, Makefile> cache_;
+  std::unordered_map<std::string, Makefile> cache_;
 };
 
 MakefileCacheManager& MakefileCacheManager::Get() {
diff --git a/src/file_cache.h b/src/file_cache.h
index 2dca448..ce1cd9c 100644
--- a/src/file_cache.h
+++ b/src/file_cache.h
@@ -18,16 +18,14 @@
 #include <string>
 #include <unordered_set>
 
-using namespace std;
-
 class Makefile;
 
 class MakefileCacheManager {
  public:
   virtual ~MakefileCacheManager();
 
-  virtual const Makefile& ReadMakefile(const string& filename) = 0;
-  virtual void GetAllFilenames(unordered_set<string>* out) = 0;
+  virtual const Makefile& ReadMakefile(const std::string& filename) = 0;
+  virtual void GetAllFilenames(std::unordered_set<std::string>* out) = 0;
 
   static MakefileCacheManager& Get();
 
diff --git a/src/fileutil.cc b/src/fileutil.cc
index 14ee68a..f70d44a 100644
--- a/src/fileutil.cc
+++ b/src/fileutil.cc
@@ -63,15 +63,15 @@ double GetTimestamp(StringPiece filename) {
   return GetTimestampFromStat(st);
 }
 
-int RunCommand(const string& shell,
-               const string& shellflag,
-               const string& cmd,
+int RunCommand(const std::string& shell,
+               const std::string& shellflag,
+               const std::string& cmd,
                RedirectStderr redirect_stderr,
-               string* s) {
+               std::string* s) {
   const char* argv[] = {NULL, NULL, NULL, NULL};
-  string cmd_with_shell;
-  if (shell[0] != '/' || shell.find_first_of(" $") != string::npos) {
-    string cmd_escaped = cmd;
+  std::string cmd_with_shell;
+  if (shell[0] != '/' || shell.find_first_of(" $") != std::string::npos) {
+    std::string cmd_escaped = cmd;
     EscapeShell(&cmd_escaped);
     cmd_with_shell = shell + " " + shellflag + " \"" + cmd_escaped + "\"";
     argv[0] = "/bin/sh";
diff --git a/src/fileutil.h b/src/fileutil.h
index 1ff4fc1..47751eb 100644
--- a/src/fileutil.h
+++ b/src/fileutil.h
@@ -24,8 +24,6 @@
 
 #include "string_piece.h"
 
-using namespace std;
-
 bool Exists(StringPiece f);
 double GetTimestampFromStat(const struct stat& st);
 double GetTimestamp(StringPiece f);
@@ -36,11 +34,11 @@ enum struct RedirectStderr {
   DEV_NULL,
 };
 
-int RunCommand(const string& shell,
-               const string& shellflag,
-               const string& cmd,
+int RunCommand(const std::string& shell,
+               const std::string& shellflag,
+               const std::string& cmd,
                RedirectStderr redirect_stderr,
-               string* out);
+               std::string* out);
 
 std::string GetExecutablePath();
 
diff --git a/src/find.cc b/src/find.cc
index b693449..51a6276 100644
--- a/src/find.cc
+++ b/src/find.cc
@@ -50,7 +50,7 @@ static unsigned int find_emulator_node_cnt = 0;
 class FindCond {
  public:
   virtual ~FindCond() = default;
-  virtual bool IsTrue(const string& path, unsigned char type) const = 0;
+  virtual bool IsTrue(const std::string& path, unsigned char type) const = 0;
   virtual bool Countable() const = 0;
   virtual unsigned Count() const = 0;
 
@@ -62,24 +62,24 @@ namespace {
 
 class NameCond : public FindCond {
  public:
-  explicit NameCond(const string& n) : name_(n) {
-    has_wildcard_ = (n.find_first_of("?*[") != string::npos);
+  explicit NameCond(const std::string& n) : name_(n) {
+    has_wildcard_ = (n.find_first_of("?*[") != std::string::npos);
   }
-  virtual bool IsTrue(const string& path, unsigned char) const override {
+  virtual bool IsTrue(const std::string& path, unsigned char) const override {
     return fnmatch(name_.c_str(), Basename(path).data(), 0) == 0;
   }
   virtual bool Countable() const override { return !has_wildcard_; }
   virtual unsigned Count() const override { return 1; }
 
  private:
-  string name_;
+  std::string name_;
   bool has_wildcard_;
 };
 
 class TypeCond : public FindCond {
  public:
   explicit TypeCond(unsigned char t) : type_(t) {}
-  virtual bool IsTrue(const string&, unsigned char type) const override {
+  virtual bool IsTrue(const std::string&, unsigned char type) const override {
     return type == type_;
   }
   virtual bool Countable() const override { return false; }
@@ -92,20 +92,22 @@ class TypeCond : public FindCond {
 class NotCond : public FindCond {
  public:
   NotCond(FindCond* c) : c_(c) {}
-  virtual bool IsTrue(const string& path, unsigned char type) const override {
+  virtual bool IsTrue(const std::string& path,
+                      unsigned char type) const override {
     return !c_->IsTrue(path, type);
   }
   virtual bool Countable() const override { return false; }
   virtual unsigned Count() const override { return 0; }
 
  private:
-  unique_ptr<FindCond> c_;
+  std::unique_ptr<FindCond> c_;
 };
 
 class AndCond : public FindCond {
  public:
   AndCond(FindCond* c1, FindCond* c2) : c1_(c1), c2_(c2) {}
-  virtual bool IsTrue(const string& path, unsigned char type) const override {
+  virtual bool IsTrue(const std::string& path,
+                      unsigned char type) const override {
     if (c1_->IsTrue(path, type))
       return c2_->IsTrue(path, type);
     return false;
@@ -114,13 +116,14 @@ class AndCond : public FindCond {
   virtual unsigned Count() const override { return 0; }
 
  private:
-  unique_ptr<FindCond> c1_, c2_;
+  std::unique_ptr<FindCond> c1_, c2_;
 };
 
 class OrCond : public FindCond {
  public:
   OrCond(FindCond* c1, FindCond* c2) : c1_(c1), c2_(c2) {}
-  virtual bool IsTrue(const string& path, unsigned char type) const override {
+  virtual bool IsTrue(const std::string& path,
+                      unsigned char type) const override {
     if (!c1_->IsTrue(path, type))
       return c2_->IsTrue(path, type);
     return true;
@@ -134,7 +137,7 @@ class OrCond : public FindCond {
   }
 
  private:
-  unique_ptr<FindCond> c1_, c2_;
+  std::unique_ptr<FindCond> c1_, c2_;
 };
 
 class DirentNode {
@@ -142,33 +145,35 @@ class DirentNode {
   virtual ~DirentNode() = default;
 
   virtual const DirentNode* FindDir(StringPiece) const { return NULL; }
-  virtual bool FindNodes(const FindCommand&,
-                         vector<pair<string, const DirentNode*>>&,
-                         string*,
-                         StringPiece) const {
+  virtual bool FindNodes(
+      const FindCommand&,
+      std::vector<std::pair<std::string, const DirentNode*>>&,
+      std::string*,
+      StringPiece) const {
     return true;
   }
-  virtual bool RunFind(const FindCommand& fc,
-                       const Loc& loc,
-                       int d,
-                       string* path,
-                       unordered_map<const DirentNode*, string>* cur_read_dirs,
-                       vector<string>& out) const = 0;
+  virtual bool RunFind(
+      const FindCommand& fc,
+      const Loc& loc,
+      int d,
+      std::string* path,
+      std::unordered_map<const DirentNode*, std::string>* cur_read_dirs,
+      std::vector<std::string>& out) const = 0;
 
   virtual bool IsDirectory() const = 0;
 
-  const string& base() const { return base_; }
+  const std::string& base() const { return base_; }
 
  protected:
-  explicit DirentNode(const string& name) {
+  explicit DirentNode(const std::string& name) {
     base_ = Basename(name).as_string();
   }
 
   void PrintIfNecessary(const FindCommand& fc,
-                        const string& path,
+                        const std::string& path,
                         unsigned char type,
                         int d,
-                        vector<string>& out) const {
+                        std::vector<std::string>& out) const {
     if (fc.print_cond && !fc.print_cond->IsTrue(path, type))
       return;
     if (d < fc.mindepth)
@@ -176,20 +181,20 @@ class DirentNode {
     out.push_back(path);
   }
 
-  string base_;
+  std::string base_;
 };
 
 class DirentFileNode : public DirentNode {
  public:
-  DirentFileNode(const string& name, unsigned char type)
+  DirentFileNode(const std::string& name, unsigned char type)
       : DirentNode(name), type_(type) {}
 
   virtual bool RunFind(const FindCommand& fc,
                        const Loc&,
                        int d,
-                       string* path,
-                       unordered_map<const DirentNode*, string>*,
-                       vector<string>& out) const override {
+                       std::string* path,
+                       std::unordered_map<const DirentNode*, std::string>*,
+                       std::vector<std::string>& out) const override {
     PrintIfNecessary(fc, *path, type_, d, out);
     return true;
   }
@@ -202,9 +207,10 @@ class DirentFileNode : public DirentNode {
 
 struct ScopedReadDirTracker {
  public:
-  ScopedReadDirTracker(const DirentNode* n,
-                       const string& path,
-                       unordered_map<const DirentNode*, string>* cur_read_dirs)
+  ScopedReadDirTracker(
+      const DirentNode* n,
+      const std::string& path,
+      std::unordered_map<const DirentNode*, std::string>* cur_read_dirs)
       : n_(NULL), cur_read_dirs_(cur_read_dirs) {
     const auto& p = cur_read_dirs->emplace(n, path);
     if (p.second) {
@@ -220,17 +226,17 @@ struct ScopedReadDirTracker {
   }
 
   bool ok() const { return conflicted_.empty(); }
-  const string& conflicted() const { return conflicted_; }
+  const std::string& conflicted() const { return conflicted_; }
 
  private:
-  string conflicted_;
+  std::string conflicted_;
   const DirentNode* n_;
-  unordered_map<const DirentNode*, string>* cur_read_dirs_;
+  std::unordered_map<const DirentNode*, std::string>* cur_read_dirs_;
 };
 
 class DirentDirNode : public DirentNode {
  public:
-  explicit DirentDirNode(const DirentDirNode* parent, const string& name)
+  explicit DirentDirNode(const DirentDirNode* parent, const std::string& name)
       : DirentNode(name), parent_(parent), name_(name) {}
 
   ~DirentDirNode() {
@@ -250,7 +256,7 @@ class DirentDirNode : public DirentNode {
       return parent_;
 
     size_t index = d.find('/');
-    const string& p = d.substr(0, index).as_string();
+    const std::string& p = d.substr(0, index).as_string();
     if (p.empty() || p == ".")
       return FindDir(d.substr(index + 1));
     if (p == "..") {
@@ -261,7 +267,7 @@ class DirentDirNode : public DirentNode {
 
     for (auto& child : children_) {
       if (p == child.first) {
-        if (index == string::npos)
+        if (index == std::string::npos)
           return child.second;
         StringPiece nd = d.substr(index + 1);
         return child.second->FindDir(nd);
@@ -270,10 +276,11 @@ class DirentDirNode : public DirentNode {
     return NULL;
   }
 
-  virtual bool FindNodes(const FindCommand& fc,
-                         vector<pair<string, const DirentNode*>>& results,
-                         string* path,
-                         StringPiece d) const override {
+  virtual bool FindNodes(
+      const FindCommand& fc,
+      std::vector<std::pair<std::string, const DirentNode*>>& results,
+      std::string* path,
+      StringPiece d) const override {
     if (!is_initialized_) {
       initialize();
     }
@@ -284,11 +291,11 @@ class DirentDirNode : public DirentNode {
     size_t orig_path_size = path->size();
 
     size_t index = d.find('/');
-    const string& p = d.substr(0, index).as_string();
+    const std::string& p = d.substr(0, index).as_string();
 
     if (p.empty() || p == ".") {
       path->append(p);
-      if (index == string::npos) {
+      if (index == std::string::npos) {
         results.emplace_back(*path, this);
         return true;
       }
@@ -301,14 +308,14 @@ class DirentDirNode : public DirentNode {
         return false;
       }
       path->append(p);
-      if (index == string::npos) {
+      if (index == std::string::npos) {
         results.emplace_back(*path, parent_);
         return true;
       }
       return parent_->FindNodes(fc, results, path, d.substr(index + 1));
     }
 
-    bool is_wild = p.find_first_of("?*[") != string::npos;
+    bool is_wild = p.find_first_of("?*[") != std::string::npos;
     if (is_wild) {
       fc.read_dirs->insert(*path);
     }
@@ -322,7 +329,7 @@ class DirentDirNode : public DirentNode {
       }
       if (matches) {
         path->append(child.first);
-        if (index == string::npos) {
+        if (index == std::string::npos) {
           results.emplace_back(*path, child.second);
         } else {
           if (!child.second->FindNodes(fc, results, path,
@@ -337,12 +344,13 @@ class DirentDirNode : public DirentNode {
     return true;
   }
 
-  virtual bool RunFind(const FindCommand& fc,
-                       const Loc& loc,
-                       int d,
-                       string* path,
-                       unordered_map<const DirentNode*, string>* cur_read_dirs,
-                       vector<string>& out) const override {
+  virtual bool RunFind(
+      const FindCommand& fc,
+      const Loc& loc,
+      int d,
+      std::string* path,
+      std::unordered_map<const DirentNode*, std::string>* cur_read_dirs,
+      std::vector<std::string>& out) const override {
     if (!is_initialized_) {
       initialize();
     }
@@ -450,7 +458,7 @@ class DirentDirNode : public DirentNode {
     }
   }
 
-  static unsigned char GetDtType(const string& path) {
+  static unsigned char GetDtType(const std::string& path) {
     struct stat st;
     if (lstat(path.c_str(), &st)) {
       PERROR("stat for %s", path.c_str());
@@ -462,14 +470,15 @@ class DirentDirNode : public DirentNode {
 
   const DirentDirNode* parent_;
 
-  mutable vector<pair<string, DirentNode*>> children_;
-  mutable string name_;
+  mutable std::vector<std::pair<std::string, DirentNode*>> children_;
+  mutable std::string name_;
   mutable bool is_initialized_ = false;
 };
 
 class DirentSymlinkNode : public DirentNode {
  public:
-  explicit DirentSymlinkNode(const DirentDirNode* parent, const string& name)
+  explicit DirentSymlinkNode(const DirentDirNode* parent,
+                             const std::string& name)
       : DirentNode(name), name_(name), parent_(parent) {}
 
   virtual const DirentNode* FindDir(StringPiece d) const override {
@@ -481,10 +490,11 @@ class DirentSymlinkNode : public DirentNode {
     return NULL;
   }
 
-  virtual bool FindNodes(const FindCommand& fc,
-                         vector<pair<string, const DirentNode*>>& results,
-                         string* path,
-                         StringPiece d) const override {
+  virtual bool FindNodes(
+      const FindCommand& fc,
+      std::vector<std::pair<std::string, const DirentNode*>>& results,
+      std::string* path,
+      StringPiece d) const override {
     if (!is_initialized_) {
       initialize();
     }
@@ -500,12 +510,13 @@ class DirentSymlinkNode : public DirentNode {
     return to_->FindNodes(fc, results, path, d);
   }
 
-  virtual bool RunFind(const FindCommand& fc,
-                       const Loc& loc,
-                       int d,
-                       string* path,
-                       unordered_map<const DirentNode*, string>* cur_read_dirs,
-                       vector<string>& out) const override {
+  virtual bool RunFind(
+      const FindCommand& fc,
+      const Loc& loc,
+      int d,
+      std::string* path,
+      std::unordered_map<const DirentNode*, std::string>* cur_read_dirs,
+      std::vector<std::string>& out) const override {
     unsigned char type = DT_LNK;
     if (fc.follows_symlinks && !is_initialized_) {
       initialize();
@@ -570,7 +581,7 @@ class DirentSymlinkNode : public DirentNode {
     is_initialized_ = true;
   }
 
-  mutable string name_;
+  mutable std::string name_;
   const DirentDirNode* parent_;
 
   mutable const DirentNode* to_ = nullptr;
@@ -598,7 +609,7 @@ void DirentDirNode::initialize() const {
         !strcmp(ent->d_name, ".repo") || !strcmp(ent->d_name, ".git"))
       continue;
 
-    string npath = name_;
+    std::string npath = name_;
     if (!name_.empty())
       npath += '/';
     npath += ent->d_name;
@@ -686,7 +697,7 @@ class FindCommandParser {
       }
       // But if there are any others, we can't support it, as unescaping would
       // require allocation
-      if (tok->find("\\") != string::npos) {
+      if (tok->find("\\") != std::string::npos) {
         return false;
       }
     }
@@ -716,14 +727,14 @@ class FindCommandParser {
     if (tok == "-not" || tok == "!") {
       if (!GetNextToken(&tok) || tok.empty())
         return NULL;
-      unique_ptr<FindCond> c(ParseFact(tok));
+      std::unique_ptr<FindCond> c(ParseFact(tok));
       if (!c.get())
         return NULL;
       return new NotCond(c.release());
     } else if (tok == "(") {
       if (!GetNextToken(&tok) || tok.empty())
         return NULL;
-      unique_ptr<FindCond> c(ParseExpr(tok));
+      std::unique_ptr<FindCond> c(ParseExpr(tok));
       if (!GetNextToken(&tok) || tok != ")") {
         return NULL;
       }
@@ -760,7 +771,7 @@ class FindCommandParser {
   }
 
   FindCond* ParseTerm(StringPiece tok) {
-    unique_ptr<FindCond> c(ParseFact(tok));
+    std::unique_ptr<FindCond> c(ParseFact(tok));
     if (!c.get())
       return NULL;
     while (true) {
@@ -776,7 +787,7 @@ class FindCommandParser {
           return c.release();
         }
       }
-      unique_ptr<FindCond> r(ParseFact(tok));
+      std::unique_ptr<FindCond> r(ParseFact(tok));
       if (!r.get()) {
         return NULL;
       }
@@ -785,7 +796,7 @@ class FindCommandParser {
   }
 
   FindCond* ParseExpr(StringPiece tok) {
-    unique_ptr<FindCond> c(ParseTerm(tok));
+    std::unique_ptr<FindCond> c(ParseTerm(tok));
     if (!c.get())
       return NULL;
     while (true) {
@@ -797,7 +808,7 @@ class FindCommandParser {
       }
       if (!GetNextToken(&tok) || tok.empty())
         return NULL;
-      unique_ptr<FindCond> r(ParseTerm(tok));
+      std::unique_ptr<FindCond> r(ParseTerm(tok));
       if (!r.get()) {
         return NULL;
       }
@@ -841,7 +852,7 @@ class FindCommandParser {
       } else if (tok == "-maxdepth") {
         if (!GetNextToken(&tok) || tok.empty())
           return false;
-        const string& depth_str = tok.as_string();
+        const std::string& depth_str = tok.as_string();
         char* endptr;
         long d = strtol(depth_str.c_str(), &endptr, 10);
         if (endptr != depth_str.data() + depth_str.size() || d < 0 ||
@@ -861,7 +872,7 @@ class FindCommandParser {
           return false;
         }
         fc_->redirect_to_devnull = true;
-      } else if (tok.find_first_of("|;&><'\"") != string::npos) {
+      } else if (tok.find_first_of("|;&><'\"") != std::string::npos) {
         return false;
       } else {
         fc_->finddirs.push_back(tok.as_string());
@@ -873,7 +884,7 @@ class FindCommandParser {
     fc_->type = FindCommandType::FINDLEAVES;
     fc_->follows_symlinks = true;
     StringPiece tok;
-    vector<string> findfiles;
+    std::vector<std::string> findfiles;
     while (true) {
       if (!GetNextToken(&tok))
         return false;
@@ -909,7 +920,8 @@ class FindCommandParser {
         CHECK(!fc_->prune_cond.get());
         fc_->prune_cond.reset(cond);
       } else if (HasPrefix(tok, "--mindepth=")) {
-        string mindepth_str = tok.substr(strlen("--mindepth=")).as_string();
+        std::string mindepth_str =
+            tok.substr(strlen("--mindepth=")).as_string();
         char* endptr;
         long d = strtol(mindepth_str.c_str(), &endptr, 10);
         if (endptr != mindepth_str.data() + mindepth_str.size() ||
@@ -945,7 +957,7 @@ class FindCommandParser {
       if (tok == "cd") {
         if (!GetNextToken(&tok) || tok.empty() || !fc_->chdir.empty())
           return false;
-        if (tok.find_first_of("?*[") != string::npos)
+        if (tok.find_first_of("?*[") != std::string::npos)
           return false;
         fc_->chdir = tok.as_string();
         if (!GetNextToken(&tok) || (tok != ";" && tok != "&&"))
@@ -1018,10 +1030,10 @@ class FindEmulatorImpl : public FindEmulator {
     return r;
   }
 
-  virtual bool HandleFind(const string& cmd UNUSED,
+  virtual bool HandleFind(const std::string& cmd UNUSED,
                           const FindCommand& fc,
                           const Loc& loc,
-                          string* out) override {
+                          std::string* out) override {
     if (!CanHandle(fc.chdir)) {
       LOG("FindEmulator: Cannot handle chdir (%.*s): %s", SPF(fc.chdir),
           cmd.c_str());
@@ -1063,17 +1075,17 @@ class FindEmulatorImpl : public FindEmulator {
       }
     }
 
-    vector<string> results;
-    for (const string& finddir : fc.finddirs) {
-      string fullpath = ConcatDir(fc.chdir, finddir);
+    std::vector<std::string> results;
+    for (const std::string& finddir : fc.finddirs) {
+      std::string fullpath = ConcatDir(fc.chdir, finddir);
       if (!CanHandle(fullpath)) {
         LOG("FindEmulator: Cannot handle find dir (%s): %s", fullpath.c_str(),
             cmd.c_str());
         return false;
       }
 
-      string findnodestr;
-      vector<pair<string, const DirentNode*>> bases;
+      std::string findnodestr;
+      std::vector<std::pair<std::string, const DirentNode*>> bases;
       if (!root->FindNodes(fc, bases, &findnodestr, finddir)) {
         return false;
       }
@@ -1093,7 +1105,7 @@ class FindEmulatorImpl : public FindEmulator {
       sort(bases.begin(), bases.end());
 
       for (auto [path, base] : bases) {
-        unordered_map<const DirentNode*, string> cur_read_dirs;
+        std::unordered_map<const DirentNode*, std::string> cur_read_dirs;
         if (!base->RunFind(fc, loc, 0, &path, &cur_read_dirs, results)) {
           LOG("FindEmulator: RunFind failed: %s", cmd.c_str());
           return false;
@@ -1104,7 +1116,7 @@ class FindEmulatorImpl : public FindEmulator {
     if (results.size() > 0) {
       // Calculate and reserve necessary space in out
       size_t new_length = 0;
-      for (const string& result : results) {
+      for (const std::string& result : results) {
         new_length += result.size() + 1;
       }
       out->reserve(out->size() + new_length - 1);
@@ -1114,7 +1126,7 @@ class FindEmulatorImpl : public FindEmulator {
       }
 
       WordWriter writer(out);
-      for (const string& result : results) {
+      for (const std::string& result : results) {
         writer.Write(result);
       }
     }
@@ -1134,12 +1146,12 @@ FindCommand::FindCommand()
       depth(INT_MAX),
       mindepth(INT_MIN),
       redirect_to_devnull(false),
-      found_files(new vector<string>()),
-      read_dirs(new unordered_set<string>()) {}
+      found_files(new std::vector<std::string>()),
+      read_dirs(new std::unordered_set<std::string>()) {}
 
 FindCommand::~FindCommand() {}
 
-bool FindCommand::Parse(const string& cmd) {
+bool FindCommand::Parse(const std::string& cmd) {
   FindCommandParser fcp(cmd, this);
   if (!HasWord(cmd, "find") && !HasWord(cmd, "build/tools/findleaves.py") &&
       !HasWord(cmd, "build/make/tools/findleaves.py"))
diff --git a/src/find.h b/src/find.h
index 2a1abe4..24407e9 100644
--- a/src/find.h
+++ b/src/find.h
@@ -23,8 +23,6 @@
 #include "loc.h"
 #include "string_piece.h"
 
-using namespace std;
-
 class FindCond;
 
 enum struct FindCommandType {
@@ -37,21 +35,21 @@ struct FindCommand {
   FindCommand();
   ~FindCommand();
 
-  bool Parse(const string& cmd);
+  bool Parse(const std::string& cmd);
 
   FindCommandType type;
-  string chdir;
-  string testdir;
-  vector<string> finddirs;
+  std::string chdir;
+  std::string testdir;
+  std::vector<std::string> finddirs;
   bool follows_symlinks;
-  unique_ptr<FindCond> print_cond;
-  unique_ptr<FindCond> prune_cond;
+  std::unique_ptr<FindCond> print_cond;
+  std::unique_ptr<FindCond> prune_cond;
   int depth;
   int mindepth;
   bool redirect_to_devnull;
 
-  unique_ptr<vector<string>> found_files;
-  unique_ptr<unordered_set<string>> read_dirs;
+  std::unique_ptr<std::vector<std::string>> found_files;
+  std::unique_ptr<std::unordered_set<std::string>> read_dirs;
 
  private:
   FindCommand(const FindCommand&) = delete;
@@ -62,10 +60,10 @@ class FindEmulator {
  public:
   virtual ~FindEmulator() = default;
 
-  virtual bool HandleFind(const string& cmd,
+  virtual bool HandleFind(const std::string& cmd,
                           const FindCommand& fc,
                           const Loc& loc,
-                          string* out) = 0;
+                          std::string* out) = 0;
 
   static FindEmulator* Get();
   static unsigned int GetNodeCount();
diff --git a/src/find_test.cc b/src/find_test.cc
index e8d521c..b8502f9 100644
--- a/src/find_test.cc
+++ b/src/find_test.cc
@@ -32,7 +32,7 @@ int main(int argc, char* argv[]) {
   }
 
   InitFindEmulator();
-  string cmd;
+  std::string cmd;
   for (int i = 1; i < argc; i++) {
     if (i > 1)
       cmd += ' ';
@@ -43,7 +43,7 @@ int main(int argc, char* argv[]) {
     fprintf(stderr, "Find emulator does not support this command\n");
     return 1;
   }
-  string out;
+  std::string out;
   if (!FindEmulator::Get()->HandleFind(cmd, fc, Loc(), &out)) {
     fprintf(stderr, "Find emulator does not support this command\n");
     return 1;
@@ -54,8 +54,8 @@ int main(int argc, char* argv[]) {
   }
 }
 
-string Run(const string& cmd) {
-  string s;
+std::string Run(const std::string& cmd) {
+  std::string s;
   int ret = RunCommand("/bin/sh", "-c", cmd, RedirectStderr::NONE, &s);
 
   if (ret != 0) {
@@ -68,22 +68,22 @@ string Run(const string& cmd) {
 
 static bool unit_test_failed = false;
 
-void CompareFind(const string& cmd) {
-  string native = Run(cmd);
+void CompareFind(const std::string& cmd) {
+  std::string native = Run(cmd);
 
   FindCommand fc;
   if (!fc.Parse(cmd)) {
     fprintf(stderr, "Find emulator cannot parse `%s`\n", cmd.c_str());
     exit(1);
   }
-  string emulated;
+  std::string emulated;
   if (!FindEmulator::Get()->HandleFind(cmd, fc, Loc(), &emulated)) {
     fprintf(stderr, "Find emulator cannot handle `%s`\n", cmd.c_str());
     exit(1);
   }
 
-  vector<StringPiece> nativeWords;
-  vector<StringPiece> emulatedWords;
+  std::vector<StringPiece> nativeWords;
+  std::vector<StringPiece> emulatedWords;
 
   WordScanner(native).Split(&nativeWords);
   WordScanner(emulated).Split(&emulatedWords);
@@ -109,7 +109,7 @@ void CompareFind(const string& cmd) {
   }
 }
 
-void ExpectParseFailure(const string& cmd) {
+void ExpectParseFailure(const std::string& cmd) {
   FindCommand fc;
   if (fc.Parse(cmd)) {
     fprintf(stderr, "Expected parse failure for `%s`\n", cmd.c_str());
diff --git a/src/flags.cc b/src/flags.cc
index 1bba336..ea2a663 100644
--- a/src/flags.cc
+++ b/src/flags.cc
@@ -57,7 +57,7 @@ void Flags::Parse(int argc, char** argv) {
 
   if (const char* makeflags = getenv("MAKEFLAGS")) {
     for (StringPiece tok : WordScanner(makeflags)) {
-      if (!HasPrefix(tok, "-") && tok.find('=') != string::npos)
+      if (!HasPrefix(tok, "-") && tok.find('=') != std::string::npos)
         cl_vars.push_back(tok);
     }
   }
diff --git a/src/flags.h b/src/flags.h
index e173730..83bbe78 100644
--- a/src/flags.h
+++ b/src/flags.h
@@ -22,8 +22,6 @@
 #include "strutil.h"
 #include "symtab.h"
 
-using namespace std;
-
 struct Flags {
   bool detect_android_echo;
   bool detect_depfiles;
@@ -77,11 +75,11 @@ struct Flags {
   int num_cpus;
   int num_jobs;
   int remote_num_jobs;
-  vector<const char*> subkati_args;
-  vector<Symbol> targets;
-  vector<StringPiece> cl_vars;
-  vector<string> writable;
-  vector<Pattern> traced_variables_pattern;
+  std::vector<const char*> subkati_args;
+  std::vector<Symbol> targets;
+  std::vector<StringPiece> cl_vars;
+  std::vector<std::string> writable;
+  std::vector<Pattern> traced_variables_pattern;
 
   void Parse(int argc, char** argv);
 };
diff --git a/src/func.cc b/src/func.cc
index 89f9e16..1171deb 100644
--- a/src/func.cc
+++ b/src/func.cc
@@ -45,11 +45,11 @@ namespace {
 
 // TODO: This code is very similar to
 // NinjaGenerator::TranslateCommand. Factor them out.
-void StripShellComment(string* cmd) {
-  if (cmd->find('#') == string::npos)
+void StripShellComment(std::string* cmd) {
+  if (cmd->find('#') == std::string::npos)
     return;
 
-  string res;
+  std::string res;
   bool prev_backslash = false;
   // Set space as an initial value so the leading comment will be
   // stripped out.
@@ -98,10 +98,12 @@ void StripShellComment(string* cmd) {
   cmd->swap(res);
 }
 
-void PatsubstFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& pat_str = args[0]->Eval(ev);
-  const string&& repl = args[1]->Eval(ev);
-  const string&& str = args[2]->Eval(ev);
+void PatsubstFunc(const std::vector<Value*>& args,
+                  Evaluator* ev,
+                  std::string* s) {
+  const std::string&& pat_str = args[0]->Eval(ev);
+  const std::string&& repl = args[1]->Eval(ev);
+  const std::string&& str = args[2]->Eval(ev);
   WordWriter ww(s);
   Pattern pat(pat_str);
   for (StringPiece tok : WordScanner(str)) {
@@ -110,18 +112,18 @@ void PatsubstFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   }
 }
 
-void StripFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& str = args[0]->Eval(ev);
+void StripFunc(const std::vector<Value*>& args, Evaluator* ev, std::string* s) {
+  const std::string&& str = args[0]->Eval(ev);
   WordWriter ww(s);
   for (StringPiece tok : WordScanner(str)) {
     ww.Write(tok);
   }
 }
 
-void SubstFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& pat = args[0]->Eval(ev);
-  const string&& repl = args[1]->Eval(ev);
-  const string&& str = args[2]->Eval(ev);
+void SubstFunc(const std::vector<Value*>& args, Evaluator* ev, std::string* s) {
+  const std::string&& pat = args[0]->Eval(ev);
+  const std::string&& repl = args[1]->Eval(ev);
+  const std::string&& str = args[2]->Eval(ev);
   if (pat.empty()) {
     *s += str;
     *s += repl;
@@ -130,7 +132,7 @@ void SubstFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   size_t index = 0;
   while (index < str.size()) {
     size_t found = str.find(pat, index);
-    if (found == string::npos)
+    if (found == std::string::npos)
       break;
     AppendString(StringPiece(str).substr(index, found - index), s);
     AppendString(repl, s);
@@ -139,17 +141,21 @@ void SubstFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   AppendString(StringPiece(str).substr(index), s);
 }
 
-void FindstringFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& find = args[0]->Eval(ev);
-  const string&& in = args[1]->Eval(ev);
-  if (in.find(find) != string::npos)
+void FindstringFunc(const std::vector<Value*>& args,
+                    Evaluator* ev,
+                    std::string* s) {
+  const std::string&& find = args[0]->Eval(ev);
+  const std::string&& in = args[1]->Eval(ev);
+  if (in.find(find) != std::string::npos)
     AppendString(find, s);
 }
 
-void FilterFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& pat_buf = args[0]->Eval(ev);
-  const string&& text = args[1]->Eval(ev);
-  vector<Pattern> pats;
+void FilterFunc(const std::vector<Value*>& args,
+                Evaluator* ev,
+                std::string* s) {
+  const std::string&& pat_buf = args[0]->Eval(ev);
+  const std::string&& text = args[1]->Eval(ev);
+  std::vector<Pattern> pats;
   for (StringPiece pat : WordScanner(pat_buf)) {
     pats.push_back(Pattern(pat));
   }
@@ -164,10 +170,12 @@ void FilterFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   }
 }
 
-void FilterOutFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& pat_buf = args[0]->Eval(ev);
-  const string&& text = args[1]->Eval(ev);
-  vector<Pattern> pats;
+void FilterOutFunc(const std::vector<Value*>& args,
+                   Evaluator* ev,
+                   std::string* s) {
+  const std::string&& pat_buf = args[0]->Eval(ev);
+  const std::string&& text = args[1]->Eval(ev);
+  std::vector<Pattern> pats;
   for (StringPiece pat : WordScanner(pat_buf)) {
     pats.push_back(Pattern(pat));
   }
@@ -185,13 +193,13 @@ void FilterOutFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   }
 }
 
-void SortFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  string list;
+void SortFunc(const std::vector<Value*>& args, Evaluator* ev, std::string* s) {
+  std::string list;
   args[0]->Eval(ev, &list);
   COLLECT_STATS("func sort time");
   // TODO(hamaji): Probably we could use a faster string-specific sort
   // algorithm.
-  vector<StringPiece> toks;
+  std::vector<StringPiece> toks;
   WordScanner(list).Split(&toks);
   stable_sort(toks.begin(), toks.end());
   WordWriter ww(s);
@@ -204,7 +212,7 @@ void SortFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   }
 }
 
-static int GetNumericValueForFunc(const string& buf) {
+static int GetNumericValueForFunc(const std::string& buf) {
   StringPiece s = TrimLeftSpace(buf);
   char* end;
   long n = strtol(s.data(), &end, 10);
@@ -214,8 +222,8 @@ static int GetNumericValueForFunc(const string& buf) {
   return n;
 }
 
-void WordFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& n_str = args[0]->Eval(ev);
+void WordFunc(const std::vector<Value*>& args, Evaluator* ev, std::string* s) {
+  const std::string&& n_str = args[0]->Eval(ev);
   int n = GetNumericValueForFunc(n_str);
   if (n < 0) {
     ev->Error(
@@ -226,7 +234,7 @@ void WordFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
     ev->Error("*** first argument to `word' function must be greater than 0.");
   }
 
-  const string&& text = args[1]->Eval(ev);
+  const std::string&& text = args[1]->Eval(ev);
   for (StringPiece tok : WordScanner(text)) {
     n--;
     if (n == 0) {
@@ -236,8 +244,10 @@ void WordFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   }
 }
 
-void WordlistFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& s_str = args[0]->Eval(ev);
+void WordlistFunc(const std::vector<Value*>& args,
+                  Evaluator* ev,
+                  std::string* s) {
+  const std::string&& s_str = args[0]->Eval(ev);
   int si = GetNumericValueForFunc(s_str);
   if (si < 0) {
     ev->Error(StringPrintf(
@@ -250,7 +260,7 @@ void WordlistFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
                      s_str.c_str()));
   }
 
-  const string&& e_str = args[1]->Eval(ev);
+  const std::string&& e_str = args[1]->Eval(ev);
   int ei = GetNumericValueForFunc(e_str);
   if (ei < 0) {
     ev->Error(StringPrintf(
@@ -258,7 +268,7 @@ void WordlistFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
         e_str.c_str()));
   }
 
-  const string&& text = args[2]->Eval(ev);
+  const std::string&& text = args[2]->Eval(ev);
   int i = 0;
   WordWriter ww(s);
   for (StringPiece tok : WordScanner(text)) {
@@ -269,8 +279,8 @@ void WordlistFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   }
 }
 
-void WordsFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& text = args[0]->Eval(ev);
+void WordsFunc(const std::vector<Value*>& args, Evaluator* ev, std::string* s) {
+  const std::string&& text = args[0]->Eval(ev);
   WordScanner ws(text);
   int n = 0;
   for (auto iter = ws.begin(); iter != ws.end(); ++iter)
@@ -280,8 +290,10 @@ void WordsFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   *s += buf;
 }
 
-void FirstwordFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& text = args[0]->Eval(ev);
+void FirstwordFunc(const std::vector<Value*>& args,
+                   Evaluator* ev,
+                   std::string* s) {
+  const std::string&& text = args[0]->Eval(ev);
   WordScanner ws(text);
   auto begin = ws.begin();
   if (begin != ws.end()) {
@@ -289,8 +301,10 @@ void FirstwordFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   }
 }
 
-void LastwordFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& text = args[0]->Eval(ev);
+void LastwordFunc(const std::vector<Value*>& args,
+                  Evaluator* ev,
+                  std::string* s) {
+  const std::string&& text = args[0]->Eval(ev);
   StringPiece last;
   for (StringPiece tok : WordScanner(text)) {
     last = tok;
@@ -298,9 +312,9 @@ void LastwordFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   AppendString(last, s);
 }
 
-void JoinFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& list1 = args[0]->Eval(ev);
-  const string&& list2 = args[1]->Eval(ev);
+void JoinFunc(const std::vector<Value*>& args, Evaluator* ev, std::string* s) {
+  const std::string&& list1 = args[0]->Eval(ev);
+  const std::string&& list2 = args[1]->Eval(ev);
   WordScanner ws1(list1);
   WordScanner ws2(list2);
   WordWriter ww(s);
@@ -317,8 +331,10 @@ void JoinFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
     ww.Write(*iter2);
 }
 
-void WildcardFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& pat = args[0]->Eval(ev);
+void WildcardFunc(const std::vector<Value*>& args,
+                  Evaluator* ev,
+                  std::string* s) {
+  const std::string&& pat = args[0]->Eval(ev);
   COLLECT_STATS("func wildcard time");
   // Note GNU make does not delay the execution of $(wildcard) so we
   // do not need to check avoid_io here.
@@ -326,14 +342,14 @@ void WildcardFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   for (StringPiece tok : WordScanner(pat)) {
     ScopedTerminator st(tok);
     const auto& files = Glob(tok.data());
-    for (const string& file : files) {
+    for (const std::string& file : files) {
       ww.Write(file);
     }
   }
 }
 
-void DirFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& text = args[0]->Eval(ev);
+void DirFunc(const std::vector<Value*>& args, Evaluator* ev, std::string* s) {
+  const std::string&& text = args[0]->Eval(ev);
   WordWriter ww(s);
   for (StringPiece tok : WordScanner(text)) {
     ww.Write(Dirname(tok));
@@ -341,8 +357,10 @@ void DirFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   }
 }
 
-void NotdirFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& text = args[0]->Eval(ev);
+void NotdirFunc(const std::vector<Value*>& args,
+                Evaluator* ev,
+                std::string* s) {
+  const std::string&& text = args[0]->Eval(ev);
   WordWriter ww(s);
   for (StringPiece tok : WordScanner(text)) {
     if (tok == "/") {
@@ -353,8 +371,10 @@ void NotdirFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   }
 }
 
-void SuffixFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& text = args[0]->Eval(ev);
+void SuffixFunc(const std::vector<Value*>& args,
+                Evaluator* ev,
+                std::string* s) {
+  const std::string&& text = args[0]->Eval(ev);
   WordWriter ww(s);
   for (StringPiece tok : WordScanner(text)) {
     StringPiece suf = GetExt(tok);
@@ -363,17 +383,21 @@ void SuffixFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   }
 }
 
-void BasenameFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& text = args[0]->Eval(ev);
+void BasenameFunc(const std::vector<Value*>& args,
+                  Evaluator* ev,
+                  std::string* s) {
+  const std::string&& text = args[0]->Eval(ev);
   WordWriter ww(s);
   for (StringPiece tok : WordScanner(text)) {
     ww.Write(StripExt(tok));
   }
 }
 
-void AddsuffixFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& suf = args[0]->Eval(ev);
-  const string&& text = args[1]->Eval(ev);
+void AddsuffixFunc(const std::vector<Value*>& args,
+                   Evaluator* ev,
+                   std::string* s) {
+  const std::string&& suf = args[0]->Eval(ev);
+  const std::string&& text = args[1]->Eval(ev);
   WordWriter ww(s);
   for (StringPiece tok : WordScanner(text)) {
     ww.Write(tok);
@@ -381,9 +405,11 @@ void AddsuffixFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   }
 }
 
-void AddprefixFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& pre = args[0]->Eval(ev);
-  const string&& text = args[1]->Eval(ev);
+void AddprefixFunc(const std::vector<Value*>& args,
+                   Evaluator* ev,
+                   std::string* s) {
+  const std::string&& pre = args[0]->Eval(ev);
+  const std::string&& text = args[1]->Eval(ev);
   WordWriter ww(s);
   for (StringPiece tok : WordScanner(text)) {
     ww.Write(pre);
@@ -391,8 +417,10 @@ void AddprefixFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   }
 }
 
-void RealpathFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& text = args[0]->Eval(ev);
+void RealpathFunc(const std::vector<Value*>& args,
+                  Evaluator* ev,
+                  std::string* s) {
+  const std::string&& text = args[0]->Eval(ev);
   if (ev->avoid_io()) {
     *s += "$(";
     *s += GetExecutablePath();
@@ -411,18 +439,20 @@ void RealpathFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   }
 }
 
-void AbspathFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& text = args[0]->Eval(ev);
+void AbspathFunc(const std::vector<Value*>& args,
+                 Evaluator* ev,
+                 std::string* s) {
+  const std::string&& text = args[0]->Eval(ev);
   WordWriter ww(s);
-  string buf;
+  std::string buf;
   for (StringPiece tok : WordScanner(text)) {
     AbsPath(tok, &buf);
     ww.Write(buf);
   }
 }
 
-void IfFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& cond = args[0]->Eval(ev);
+void IfFunc(const std::vector<Value*>& args, Evaluator* ev, std::string* s) {
+  const std::string&& cond = args[0]->Eval(ev);
   if (cond.empty()) {
     if (args.size() > 2)
       args[2]->Eval(ev, s);
@@ -431,8 +461,8 @@ void IfFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   }
 }
 
-void AndFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  string cond;
+void AndFunc(const std::vector<Value*>& args, Evaluator* ev, std::string* s) {
+  std::string cond;
   for (Value* a : args) {
     cond = a->Eval(ev);
     if (cond.empty())
@@ -443,9 +473,9 @@ void AndFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   }
 }
 
-void OrFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
+void OrFunc(const std::vector<Value*>& args, Evaluator* ev, std::string* s) {
   for (Value* a : args) {
-    const string&& cond = a->Eval(ev);
+    const std::string&& cond = a->Eval(ev);
     if (!cond.empty()) {
       *s += cond;
       return;
@@ -453,24 +483,24 @@ void OrFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   }
 }
 
-void ValueFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& var_name = args[0]->Eval(ev);
+void ValueFunc(const std::vector<Value*>& args, Evaluator* ev, std::string* s) {
+  const std::string&& var_name = args[0]->Eval(ev);
   Var* var = ev->LookupVar(Intern(var_name));
   AppendString(var->String().as_string(), s);
 }
 
-void EvalFunc(const vector<Value*>& args, Evaluator* ev, string*) {
+void EvalFunc(const std::vector<Value*>& args, Evaluator* ev, std::string*) {
   // TODO: eval leaks everything... for now.
   // const string text = args[0]->Eval(ev);
   ev->CheckStack();
-  string* text = new string;
+  std::string* text = new std::string;
   args[0]->Eval(ev, text);
   if (ev->avoid_io()) {
     KATI_WARN_LOC(ev->loc(),
                   "*warning*: $(eval) in a recipe is not recommended: %s",
                   text->c_str());
   }
-  vector<Stmt*> stmts;
+  std::vector<Stmt*> stmts;
   Parse(*text, ev->loc(), &stmts);
   for (Stmt* stmt : stmts) {
     LOG("%s", stmt->DebugString().c_str());
@@ -486,7 +516,7 @@ void EvalFunc(const vector<Value*>& args, Evaluator* ev, string*) {
 // will be passed to other make functions.
 // TODO: Maybe we should introduce a helper binary which evaluate
 // make expressions at ninja-time.
-static bool HasNoIoInShellScript(const string& cmd) {
+static bool HasNoIoInShellScript(const std::string& cmd) {
   if (cmd.empty())
     return true;
   if (HasPrefix(cmd, "echo $((") && cmd[cmd.size() - 1] == ')')
@@ -494,11 +524,11 @@ static bool HasNoIoInShellScript(const string& cmd) {
   return false;
 }
 
-static int ShellFuncImpl(const string& shell,
-                         const string& shellflag,
-                         const string& cmd,
+static int ShellFuncImpl(const std::string& shell,
+                         const std::string& shellflag,
+                         const std::string& cmd,
                          const Loc& loc,
-                         string* s,
+                         std::string* s,
                          FindCommand** fc) {
   LOG("ShellFunc: %s", cmd.c_str());
 
@@ -542,7 +572,7 @@ static int ShellFuncImpl(const string& shell,
   return 1;
 }
 
-static vector<CommandResult*> g_command_results;
+static std::vector<CommandResult*> g_command_results;
 
 bool ShouldStoreCommandResult(StringPiece cmd) {
   // We really just want to ignore this one, or remove BUILD_DATETIME from
@@ -561,8 +591,8 @@ bool ShouldStoreCommandResult(StringPiece cmd) {
   return true;
 }
 
-void ShellFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  string cmd = args[0]->Eval(ev);
+void ShellFunc(const std::vector<Value*>& args, Evaluator* ev, std::string* s) {
+  std::string cmd = args[0]->Eval(ev);
   if (ev->avoid_io() && !HasNoIoInShellScript(cmd)) {
     if (ev->eval_depth() > 1) {
       ERROR_LOC(ev->loc(),
@@ -577,10 +607,10 @@ void ShellFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
     return;
   }
 
-  const string&& shell = ev->GetShell();
-  const string&& shellflag = ev->GetShellFlag();
+  const std::string&& shell = ev->GetShell();
+  const std::string&& shellflag = ev->GetShellFlag();
 
-  string out;
+  std::string out;
   FindCommand* fc = NULL;
   int returnCode = ShellFuncImpl(shell, shellflag, cmd, ev->loc(), &out, &fc);
   if (ShouldStoreCommandResult(cmd)) {
@@ -598,13 +628,13 @@ void ShellFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   ShellStatusVar::SetValue(returnCode);
 }
 
-void CallFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
+void CallFunc(const std::vector<Value*>& args, Evaluator* ev, std::string* s) {
   static const Symbol tmpvar_names[] = {
       Intern("0"), Intern("1"), Intern("2"), Intern("3"), Intern("4"),
       Intern("5"), Intern("6"), Intern("7"), Intern("8"), Intern("9")};
 
   ev->CheckStack();
-  const string&& func_name_buf = args[0]->Eval(ev);
+  const std::string&& func_name_buf = args[0]->Eval(ev);
   Symbol func_sym = Intern(TrimSpace(func_name_buf));
   Var* func = ev->LookupVar(func_sym);
   func->Used(ev, func_sym);
@@ -612,14 +642,14 @@ void CallFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
     KATI_WARN_LOC(ev->loc(), "*warning*: undefined user function: %s",
                   func_sym.c_str());
   }
-  vector<unique_ptr<SimpleVar>> av;
+  std::vector<std::unique_ptr<SimpleVar>> av;
   for (size_t i = 1; i < args.size(); i++) {
     av.emplace_back(std::make_unique<SimpleVar>(
         args[i]->Eval(ev), VarOrigin::AUTOMATIC, nullptr, Loc()));
   }
-  vector<unique_ptr<ScopedGlobalVar>> sv;
+  std::vector<std::unique_ptr<ScopedGlobalVar>> sv;
   for (size_t i = 1;; i++) {
-    string s;
+    std::string s;
     Symbol tmpvar_name_sym;
     if (i < sizeof(tmpvar_names) / sizeof(tmpvar_names[0])) {
       tmpvar_name_sym = tmpvar_names[i];
@@ -652,13 +682,15 @@ void CallFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   ev->IncrementEvalDepth();
 }
 
-void ForeachFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& varname = args[0]->Eval(ev);
-  const string&& list = args[1]->Eval(ev);
+void ForeachFunc(const std::vector<Value*>& args,
+                 Evaluator* ev,
+                 std::string* s) {
+  const std::string&& varname = args[0]->Eval(ev);
+  const std::string&& list = args[1]->Eval(ev);
   ev->DecrementEvalDepth();
   WordWriter ww(s);
   for (StringPiece tok : WordScanner(list)) {
-    unique_ptr<SimpleVar> v(
+    std::unique_ptr<SimpleVar> v(
         new SimpleVar(tok.as_string(), VarOrigin::AUTOMATIC, nullptr, Loc()));
     ScopedGlobalVar sv(Intern(varname), v.get());
     ww.MaybeAddWhitespace();
@@ -667,20 +699,24 @@ void ForeachFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   ev->IncrementEvalDepth();
 }
 
-void OriginFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& var_name = args[0]->Eval(ev);
+void OriginFunc(const std::vector<Value*>& args,
+                Evaluator* ev,
+                std::string* s) {
+  const std::string&& var_name = args[0]->Eval(ev);
   Var* var = ev->LookupVar(Intern(var_name));
   *s += GetOriginStr(var->Origin());
 }
 
-void FlavorFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
-  const string&& var_name = args[0]->Eval(ev);
+void FlavorFunc(const std::vector<Value*>& args,
+                Evaluator* ev,
+                std::string* s) {
+  const std::string&& var_name = args[0]->Eval(ev);
   Var* var = ev->LookupVar(Intern(var_name));
   *s += var->Flavor();
 }
 
-void InfoFunc(const vector<Value*>& args, Evaluator* ev, string*) {
-  const string&& a = args[0]->Eval(ev);
+void InfoFunc(const std::vector<Value*>& args, Evaluator* ev, std::string*) {
+  const std::string&& a = args[0]->Eval(ev);
   if (ev->avoid_io()) {
     ev->add_delayed_output_command(
         StringPrintf("echo -e \"%s\"", EchoEscape(a).c_str()));
@@ -690,8 +726,8 @@ void InfoFunc(const vector<Value*>& args, Evaluator* ev, string*) {
   fflush(stdout);
 }
 
-void WarningFunc(const vector<Value*>& args, Evaluator* ev, string*) {
-  const string&& a = args[0]->Eval(ev);
+void WarningFunc(const std::vector<Value*>& args, Evaluator* ev, std::string*) {
+  const std::string&& a = args[0]->Eval(ev);
   if (ev->avoid_io()) {
     ev->add_delayed_output_command(StringPrintf(
         "echo -e \"%s:%d: %s\" 2>&1", LOCF(ev->loc()), EchoEscape(a).c_str()));
@@ -700,8 +736,8 @@ void WarningFunc(const vector<Value*>& args, Evaluator* ev, string*) {
   WARN_LOC(ev->loc(), "%s", a.c_str());
 }
 
-void ErrorFunc(const vector<Value*>& args, Evaluator* ev, string*) {
-  const string&& a = args[0]->Eval(ev);
+void ErrorFunc(const std::vector<Value*>& args, Evaluator* ev, std::string*) {
+  const std::string&& a = args[0]->Eval(ev);
   if (ev->avoid_io()) {
     ev->add_delayed_output_command(
         StringPrintf("echo -e \"%s:%d: *** %s.\" 2>&1 && false",
@@ -711,7 +747,9 @@ void ErrorFunc(const vector<Value*>& args, Evaluator* ev, string*) {
   ev->Error(StringPrintf("*** %s.", a.c_str()));
 }
 
-static void FileReadFunc(Evaluator* ev, const string& filename, string* s) {
+static void FileReadFunc(Evaluator* ev,
+                         const std::string& filename,
+                         std::string* s) {
   int fd = open(filename.c_str(), O_RDONLY);
   if (fd < 0) {
     if (errno == ENOENT) {
@@ -734,7 +772,7 @@ static void FileReadFunc(Evaluator* ev, const string& filename, string* s) {
   }
 
   size_t len = st.st_size;
-  string out;
+  std::string out;
   out.resize(len);
   ssize_t r = HANDLE_EINTR(read(fd, &out[0], len));
   if (r != static_cast<ssize_t>(len)) {
@@ -760,9 +798,9 @@ static void FileReadFunc(Evaluator* ev, const string& filename, string* s) {
 }
 
 static void FileWriteFunc(Evaluator* ev,
-                          const string& filename,
+                          const std::string& filename,
                           bool append,
-                          string text) {
+                          std::string text) {
   FILE* f = fopen(filename.c_str(), append ? "ab" : "wb");
   if (f == NULL) {
     ev->Error("*** fopen failed.");
@@ -786,12 +824,12 @@ static void FileWriteFunc(Evaluator* ev,
   }
 }
 
-void FileFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
+void FileFunc(const std::vector<Value*>& args, Evaluator* ev, std::string* s) {
   if (ev->avoid_io()) {
     ev->Error("*** $(file ...) is not supported in rules.");
   }
 
-  string arg = args[0]->Eval(ev);
+  std::string arg = args[0]->Eval(ev);
   StringPiece filename = TrimSpace(arg);
 
   if (filename.size() <= 1) {
@@ -821,7 +859,7 @@ void FileFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
       ev->Error("*** Missing filename");
     }
 
-    string text;
+    std::string text;
     if (args.size() > 1) {
       text = args[1]->Eval(ev);
       if (text.size() == 0 || text.back() != '\n') {
@@ -836,9 +874,11 @@ void FileFunc(const vector<Value*>& args, Evaluator* ev, string* s) {
   }
 }
 
-void DeprecatedVarFunc(const vector<Value*>& args, Evaluator* ev, string*) {
-  string vars_str = args[0]->Eval(ev);
-  string msg;
+void DeprecatedVarFunc(const std::vector<Value*>& args,
+                       Evaluator* ev,
+                       std::string*) {
+  std::string vars_str = args[0]->Eval(ev);
+  std::string msg;
 
   if (args.size() == 2) {
     msg = ". " + args[1]->Eval(ev);
@@ -872,9 +912,11 @@ void DeprecatedVarFunc(const vector<Value*>& args, Evaluator* ev, string*) {
   }
 }
 
-void ObsoleteVarFunc(const vector<Value*>& args, Evaluator* ev, string*) {
-  string vars_str = args[0]->Eval(ev);
-  string msg;
+void ObsoleteVarFunc(const std::vector<Value*>& args,
+                     Evaluator* ev,
+                     std::string*) {
+  std::string vars_str = args[0]->Eval(ev);
+  std::string msg;
 
   if (args.size() == 2) {
     msg = ". " + args[1]->Eval(ev);
@@ -907,8 +949,10 @@ void ObsoleteVarFunc(const vector<Value*>& args, Evaluator* ev, string*) {
   }
 }
 
-void DeprecateExportFunc(const vector<Value*>& args, Evaluator* ev, string*) {
-  string msg = ". " + args[0]->Eval(ev);
+void DeprecateExportFunc(const std::vector<Value*>& args,
+                         Evaluator* ev,
+                         std::string*) {
+  std::string msg = ". " + args[0]->Eval(ev);
 
   if (ev->avoid_io()) {
     ev->Error("*** $(KATI_deprecate_export) is not supported in rules.");
@@ -923,8 +967,10 @@ void DeprecateExportFunc(const vector<Value*>& args, Evaluator* ev, string*) {
   ev->SetExportDeprecated(msg);
 }
 
-void ObsoleteExportFunc(const vector<Value*>& args, Evaluator* ev, string*) {
-  string msg = ". " + args[0]->Eval(ev);
+void ObsoleteExportFunc(const std::vector<Value*>& args,
+                        Evaluator* ev,
+                        std::string*) {
+  std::string msg = ". " + args[0]->Eval(ev);
 
   if (ev->avoid_io()) {
     ev->Error("*** $(KATI_obsolete_export) is not supported in rules.");
@@ -937,19 +983,19 @@ void ObsoleteExportFunc(const vector<Value*>& args, Evaluator* ev, string*) {
   ev->SetExportObsolete(msg);
 }
 
-void ProfileFunc(const vector<Value*>& args, Evaluator* ev, string*) {
+void ProfileFunc(const std::vector<Value*>& args, Evaluator* ev, std::string*) {
   for (auto arg : args) {
-    string files = arg->Eval(ev);
+    std::string files = arg->Eval(ev);
     for (StringPiece file : WordScanner(files)) {
       ev->ProfileMakefile(file);
     }
   }
 }
 
-void VariableLocationFunc(const vector<Value*>& args,
+void VariableLocationFunc(const std::vector<Value*>& args,
                           Evaluator* ev,
-                          string* s) {
-  string arg = args[0]->Eval(ev);
+                          std::string* s) {
+  std::string arg = args[0]->Eval(ev);
   WordWriter ww(s);
   for (StringPiece var : WordScanner(arg)) {
     Symbol sym = Intern(var);
@@ -1030,6 +1076,6 @@ const FuncInfo* GetFuncInfo(StringPiece name) {
   return &found->second;
 }
 
-const vector<CommandResult*>& GetShellCommandResults() {
+const std::vector<CommandResult*>& GetShellCommandResults() {
   return g_command_results;
 }
diff --git a/src/func.h b/src/func.h
index 206a363..f6287f5 100644
--- a/src/func.h
+++ b/src/func.h
@@ -22,11 +22,9 @@
 #include "expr.h"
 #include "loc.h"
 
-using namespace std;
-
 struct FuncInfo {
   const char* name;
-  void (*func)(const vector<Value*>& args, Evaluator* ev, string* s);
+  void (*func)(const std::vector<Value*>& args, Evaluator* ev, std::string* s);
   int arity;
   int min_arity;
   // For all parameters.
@@ -50,14 +48,14 @@ enum struct CommandOp {
 
 struct CommandResult {
   CommandOp op;
-  string shell;
-  string shellflag;
-  string cmd;
-  unique_ptr<FindCommand> find;
-  string result;
+  std::string shell;
+  std::string shellflag;
+  std::string cmd;
+  std::unique_ptr<FindCommand> find;
+  std::string result;
   Loc loc;
 };
 
-const vector<CommandResult*>& GetShellCommandResults();
+const std::vector<CommandResult*>& GetShellCommandResults();
 
 #endif  // FUNC_H_
diff --git a/src/io.cc b/src/io.cc
index 9ae1c5e..75d8940 100644
--- a/src/io.cc
+++ b/src/io.cc
@@ -37,7 +37,7 @@ int LoadInt(FILE* fp) {
   return v;
 }
 
-bool LoadString(FILE* fp, string* s) {
+bool LoadString(FILE* fp, std::string* s) {
   int len = LoadInt(fp);
   if (len < 0)
     return false;
diff --git a/src/io.h b/src/io.h
index 28316f4..eb84910 100644
--- a/src/io.h
+++ b/src/io.h
@@ -21,13 +21,11 @@
 
 #include "string_piece.h"
 
-using namespace std;
-
 void DumpInt(FILE* fp, int v);
 void DumpString(FILE* fp, StringPiece s);
 
 int LoadInt(FILE* fp);
-bool LoadString(FILE* fp, string* s);
+bool LoadString(FILE* fp, std::string* s);
 
 struct ScopedFile {
  public:
diff --git a/src/log.cc b/src/log.cc
index 62f2422..2b19018 100644
--- a/src/log.cc
+++ b/src/log.cc
@@ -59,4 +59,4 @@ void ColorWarnLog(const char* file, int line, const char* msg) {
 }
 
 bool g_log_no_exit;
-string* g_last_error;
+std::string* g_last_error;
diff --git a/src/log.h b/src/log.h
index ba0bd8b..80aef86 100644
--- a/src/log.h
+++ b/src/log.h
@@ -24,10 +24,8 @@
 #include "log.h"
 #include "stringprintf.h"
 
-using namespace std;
-
 extern bool g_log_no_exit;
-extern string* g_last_error;
+extern std::string* g_last_error;
 
 // Useful for logging-only arguments.
 #define UNUSED __attribute__((unused))
@@ -76,7 +74,7 @@ extern string* g_last_error;
       fprintf(stderr, "%s\n", StringPrintf(__VA_ARGS__).c_str()); \
       exit(1);                                                    \
     }                                                             \
-    g_last_error = new string(StringPrintf(__VA_ARGS__));         \
+    g_last_error = new std::string(StringPrintf(__VA_ARGS__));    \
   } while (0)
 
 #define CHECK(c) \
diff --git a/src/main.cc b/src/main.cc
index 417ec2c..609aaea 100644
--- a/src/main.cc
+++ b/src/main.cc
@@ -49,9 +49,9 @@ extern "C" const char* __asan_default_options() {
   return "detect_leaks=0:allow_user_segv_handler=1";
 }
 
-static void ReadBootstrapMakefile(const vector<Symbol>& targets,
-                                  vector<Stmt*>* stmts) {
-  string bootstrap =
+static void ReadBootstrapMakefile(const std::vector<Symbol>& targets,
+                                  std::vector<Stmt*>* stmts) {
+  std::string bootstrap =
       ("CC?=cc\n"
 #if defined(__APPLE__)
        "CXX?=c++\n"
@@ -103,7 +103,7 @@ static void SetVar(StringPiece l,
                    Frame* definition,
                    Loc loc) {
   size_t found = l.find('=');
-  CHECK(found != string::npos);
+  CHECK(found != std::string::npos);
   Symbol lhs = Intern(l.substr(0, found));
   StringPiece rhs = l.substr(found + 1);
   lhs.SetGlobalVar(new RecursiveVar(Value::NewLiteral(rhs.data()), origin,
@@ -203,9 +203,9 @@ SegfaultHandler::~SegfaultHandler() {
   global_handler = nullptr;
 }
 
-static int Run(const vector<Symbol>& targets,
-               const vector<StringPiece>& cl_vars,
-               const string& orig_args) {
+static int Run(const std::vector<Symbol>& targets,
+               const std::vector<StringPiece>& cl_vars,
+               const std::string& orig_args) {
   double start_time = GetTime();
 
   if (g_flags.generate_ninja && (g_flags.regen || g_flags.dump_kati_stamp)) {
@@ -236,7 +236,7 @@ static int Run(const vector<Symbol>& targets,
   }
   SegfaultHandler segfault(&ev);
 
-  vector<Stmt*> bootstrap_asts;
+  std::vector<Stmt*> bootstrap_asts;
   ReadBootstrapMakefile(targets, &bootstrap_asts);
 
   {
@@ -252,7 +252,7 @@ static int Run(const vector<Symbol>& targets,
     ScopedFrame frame(ev.Enter(FrameType::PHASE, "*command line*", Loc()));
     ev.in_command_line();
     for (StringPiece l : cl_vars) {
-      vector<Stmt*> asts;
+      std::vector<Stmt*> asts;
       Parse(Intern(l).str(), Loc("*bootstrap*", 0), &asts);
       CHECK(asts.size() == 1);
       asts[0]->Eval(&ev);
@@ -282,7 +282,7 @@ static int Run(const vector<Symbol>& targets,
     ev.DumpIncludeJSON(std::string(g_flags.dump_include_graph));
   }
 
-  vector<NamedDepNode> nodes;
+  std::vector<NamedDepNode> nodes;
   {
     ScopedFrame frame(
         ev.Enter(FrameType::PHASE, "*dependency analysis*", Loc()));
@@ -306,7 +306,7 @@ static int Run(const vector<Symbol>& targets,
     const Symbol name = p.first;
     if (p.second) {
       Var* v = ev.LookupVar(name);
-      const string&& value = v->Eval(&ev);
+      const std::string&& value = v->Eval(&ev);
       LOG("setenv(%s, %s)", name.c_str(), value.c_str());
       setenv(name.c_str(), value.c_str(), 1);
     } else {
@@ -357,7 +357,7 @@ int main(int argc, char* argv[]) {
     HandleRealpath(argc - 2, argv + 2);
     return 0;
   }
-  string orig_args;
+  std::string orig_args;
   for (int i = 0; i < argc; i++) {
     if (i)
       orig_args += ' ';
diff --git a/src/ninja.cc b/src/ninja.cc
index 11d713f..e29e965 100644
--- a/src/ninja.cc
+++ b/src/ninja.cc
@@ -817,15 +817,15 @@ class NinjaGenerator {
   const DepNode* default_target_;
 };
 
-string GetNinjaFilename() {
+std::string GetNinjaFilename() {
   return NinjaGenerator::GetFilename("build%s.ninja");
 }
 
-string GetNinjaShellScriptFilename() {
+std::string GetNinjaShellScriptFilename() {
   return NinjaGenerator::GetFilename("ninja%s.sh");
 }
 
-string GetNinjaStampFilename() {
+std::string GetNinjaStampFilename() {
   return NinjaGenerator::GetFilename(".kati_stamp%s");
 }
 
diff --git a/src/ninja.h b/src/ninja.h
index 281ce2c..932d186 100644
--- a/src/ninja.h
+++ b/src/ninja.h
@@ -30,9 +30,9 @@ void GenerateNinja(const std::vector<NamedDepNode>& nodes,
                    const std::string& orig_args,
                    double start_time);
 
-string GetNinjaFilename();
-string GetNinjaShellScriptFilename();
-string GetNinjaStampFilename();
+std::string GetNinjaFilename();
+std::string GetNinjaShellScriptFilename();
+std::string GetNinjaStampFilename();
 
 // Exposed only for test.
 bool GetDepfileFromCommand(std::string* cmd, std::string* out);
diff --git a/src/ninja_test.cc b/src/ninja_test.cc
index 15b0693..f46d2bb 100644
--- a/src/ninja_test.cc
+++ b/src/ninja_test.cc
@@ -23,9 +23,9 @@
 
 namespace {
 
-string GetDepfile(string cmd, string* new_cmd) {
+std::string GetDepfile(std::string cmd, std::string* new_cmd) {
   new_cmd->clear();
-  string r;
+  std::string r;
   if (GetDepfileFromCommand(&cmd, &r)) {
     *new_cmd = cmd;
     return r;
@@ -34,7 +34,7 @@ string GetDepfile(string cmd, string* new_cmd) {
 }
 
 void TestGetDepfile() {
-  string new_cmd;
+  std::string new_cmd;
   ASSERT_EQ(GetDepfile("g++ -c fat.cc -MD ", &new_cmd), "");
   assert(g_last_error);
   delete g_last_error;
@@ -74,7 +74,8 @@ static void TestGetGomaccPosForAndroidCompileCommand() {
                 "prebuilts/misc/linux-x86/ccache/ccache "
                 "prebuilts/clang/linux-x86/host/3.6/bin/clang++ -c foo.c"),
             39);
-  ASSERT_EQ(GetGomaccPosForAndroidCompileCommand("echo foo"), string::npos);
+  ASSERT_EQ(GetGomaccPosForAndroidCompileCommand("echo foo"),
+            std::string::npos);
 }
 
 }  // namespace
diff --git a/src/parser.cc b/src/parser.cc
index 9db7ac0..323d9f6 100644
--- a/src/parser.cc
+++ b/src/parser.cc
@@ -43,10 +43,10 @@ class Parser {
 
   typedef void (Parser::*DirectiveHandler)(StringPiece line,
                                            StringPiece directive);
-  typedef unordered_map<StringPiece, DirectiveHandler> DirectiveMap;
+  typedef std::unordered_map<StringPiece, DirectiveHandler> DirectiveMap;
 
  public:
-  Parser(StringPiece buf, const char* filename, vector<Stmt*>* stmts)
+  Parser(StringPiece buf, const char* filename, std::vector<Stmt*>* stmts)
       : buf_(buf),
         state_(ParserState::NOT_AFTER_RULE),
         stmts_(stmts),
@@ -56,7 +56,7 @@ class Parser {
         loc_(filename, 0),
         fixed_lineno_(false) {}
 
-  Parser(StringPiece buf, const Loc& loc, vector<Stmt*>* stmts)
+  Parser(StringPiece buf, const Loc& loc, std::vector<Stmt*>* stmts)
       : buf_(buf),
         state_(ParserState::NOT_AFTER_RULE),
         stmts_(stmts),
@@ -95,10 +95,10 @@ class Parser {
 
   void set_state(ParserState st) { state_ = st; }
 
-  static vector<ParseErrorStmt*> parse_errors;
+  static std::vector<ParseErrorStmt*> parse_errors;
 
  private:
-  void Error(const string& msg) {
+  void Error(const std::string& msg) {
     ParseErrorStmt* stmt = new ParseErrorStmt();
     stmt->set_loc(loc_);
     stmt->msg = msg;
@@ -152,8 +152,8 @@ class Parser {
 
   void ParseRuleOrAssign(StringPiece line) {
     size_t sep = FindThreeOutsideParen(line, ':', '=', ';');
-    if (sep == string::npos || line[sep] == ';') {
-      ParseRule(line, string::npos);
+    if (sep == std::string::npos || line[sep] == ';') {
+      ParseRule(line, std::string::npos);
     } else if (line[sep] == '=') {
       ParseAssign(line, sep);
     } else if (line.get(sep + 1) == '=') {
@@ -169,7 +169,7 @@ class Parser {
     if (current_directive_ != AssignDirective::NONE) {
       if (IsInExport())
         return;
-      if (sep != string::npos) {
+      if (sep != std::string::npos) {
         sep += orig_line_with_directives_.size() - line.size();
       }
       line = orig_line_with_directives_;
@@ -184,13 +184,13 @@ class Parser {
       return;
     }
 
-    const bool is_rule = sep != string::npos && line[sep] == ':';
+    const bool is_rule = sep != std::string::npos && line[sep] == ':';
     RuleStmt* rule_stmt = new RuleStmt();
     rule_stmt->set_loc(loc_);
 
     size_t found = FindTwoOutsideParen(line.substr(sep + 1), '=', ';');
     Loc mutable_loc(loc_);
-    if (found != string::npos) {
+    if (found != std::string::npos) {
       found += sep + 1;
       rule_stmt->lhs =
           ParseExpr(&mutable_loc, TrimSpace(line.substr(0, found)));
@@ -355,7 +355,7 @@ class Parser {
         if (quote != '\'' && quote != '"')
           return false;
         size_t end = s.find(quote, 1);
-        if (end == string::npos)
+        if (end == std::string::npos)
           return false;
         Value* v =
             ParseExpr(&mutable_loc, s.substr(1, end - 1), ParseExprOpt::NORMAL);
@@ -481,7 +481,7 @@ class Parser {
 
   StringPiece RemoveComment(StringPiece line) {
     size_t i = FindOutsideParen(line, '#');
-    if (i == string::npos)
+    if (i == std::string::npos)
       return line;
     return line.substr(0, i);
   }
@@ -510,8 +510,8 @@ class Parser {
   size_t l_;
   ParserState state_;
 
-  vector<Stmt*>* stmts_;
-  vector<Stmt*>* out_stmts_;
+  std::vector<Stmt*>* stmts_;
+  std::vector<Stmt*>* out_stmts_;
 
   StringPiece define_name_;
   int num_define_nest_;
@@ -522,7 +522,7 @@ class Parser {
   AssignDirective current_directive_;
 
   int num_if_nest_;
-  stack<IfState*> if_stack_;
+  std::stack<IfState*> if_stack_;
 
   Loc loc_;
   bool fixed_lineno_;
@@ -541,7 +541,7 @@ void Parse(Makefile* mk) {
   parser.Parse();
 }
 
-void Parse(StringPiece buf, const Loc& loc, vector<Stmt*>* out_stmts) {
+void Parse(StringPiece buf, const Loc& loc, std::vector<Stmt*>* out_stmts) {
   COLLECT_STATS("parse eval time");
   Parser parser(buf, loc, out_stmts);
   parser.Parse();
@@ -549,7 +549,7 @@ void Parse(StringPiece buf, const Loc& loc, vector<Stmt*>* out_stmts) {
 
 void ParseNotAfterRule(StringPiece buf,
                        const Loc& loc,
-                       vector<Stmt*>* out_stmts) {
+                       std::vector<Stmt*>* out_stmts) {
   Parser parser(buf, loc, out_stmts);
   parser.set_state(ParserState::NOT_AFTER_RULE);
   parser.Parse();
@@ -595,7 +595,7 @@ const size_t Parser::longest_directive_len_ = []() {
   return result;
 }();
 
-vector<ParseErrorStmt*> Parser::parse_errors;
+std::vector<ParseErrorStmt*> Parser::parse_errors;
 
 void ParseAssignStatement(StringPiece line,
                           size_t sep,
@@ -623,6 +623,6 @@ void ParseAssignStatement(StringPiece line,
   *rhs = TrimLeftSpace(line.substr(sep + 1));
 }
 
-const vector<ParseErrorStmt*>& GetParseErrors() {
+const std::vector<ParseErrorStmt*>& GetParseErrors() {
   return Parser::parse_errors;
 }
diff --git a/src/parser.h b/src/parser.h
index e42ef5b..ad855df 100644
--- a/src/parser.h
+++ b/src/parser.h
@@ -21,15 +21,13 @@
 #include "stmt.h"
 #include "string_piece.h"
 
-using namespace std;
-
 class Makefile;
 
 void Parse(Makefile* mk);
-void Parse(StringPiece buf, const Loc& loc, vector<Stmt*>* out_asts);
+void Parse(StringPiece buf, const Loc& loc, std::vector<Stmt*>* out_asts);
 void ParseNotAfterRule(StringPiece buf,
                        const Loc& loc,
-                       vector<Stmt*>* out_asts);
+                       std::vector<Stmt*>* out_asts);
 
 void ParseAssignStatement(StringPiece line,
                           size_t sep,
@@ -37,6 +35,6 @@ void ParseAssignStatement(StringPiece line,
                           StringPiece* rhs,
                           AssignOp* op);
 
-const vector<ParseErrorStmt*>& GetParseErrors();
+const std::vector<ParseErrorStmt*>& GetParseErrors();
 
 #endif  // PARSER_H_
diff --git a/src/regen.cc b/src/regen.cc
index ee2559f..d32d025 100644
--- a/src/regen.cc
+++ b/src/regen.cc
@@ -52,19 +52,19 @@ bool ShouldIgnoreDirty(StringPiece s) {
 
 class StampChecker {
   struct GlobResult {
-    string pat;
-    vector<string> result;
+    std::string pat;
+    std::vector<std::string> result;
   };
 
   struct ShellResult {
     CommandOp op;
-    string shell;
-    string shellflag;
-    string cmd;
-    string result;
-    vector<string> missing_dirs;
-    vector<string> files;
-    vector<string> read_dirs;
+    std::string shell;
+    std::string shellflag;
+    std::string cmd;
+    std::string result;
+    std::vector<std::string> missing_dirs;
+    std::vector<std::string> files;
+    std::vector<std::string> read_dirs;
   };
 
  public:
@@ -79,7 +79,7 @@ class StampChecker {
     }
   }
 
-  bool NeedsRegen(double start_time, const string& orig_args) {
+  bool NeedsRegen(double start_time, const std::string& orig_args) {
     if (IsMissingOutputs())
       RETURN_TRUE;
 
@@ -117,7 +117,7 @@ class StampChecker {
     return false;
   }
 
-  bool CheckStep1(const string& orig_args) {
+  bool CheckStep1(const std::string& orig_args) {
 #define LOAD_INT(fp)                                               \
   ({                                                               \
     int v = LoadInt(fp);                                           \
@@ -136,7 +136,7 @@ class StampChecker {
     }                                                              \
   })
 
-    const string& stamp_filename = GetNinjaStampFilename();
+    const std::string& stamp_filename = GetNinjaStampFilename();
     FILE* fp = fopen(stamp_filename.c_str(), "rb");
     if (!fp) {
       if (g_flags.regen_debug)
@@ -155,7 +155,7 @@ class StampChecker {
     if (g_flags.regen_debug)
       printf("Generated time: %f\n", gen_time);
 
-    string s, s2;
+    std::string s, s2;
     int num_files = LOAD_INT(fp);
     for (int i = 0; i < num_files; i++) {
       LOAD_STRING(fp, &s);
@@ -220,7 +220,7 @@ class StampChecker {
     }
 
     int num_globs = LOAD_INT(fp);
-    string pat;
+    std::string pat;
     for (int i = 0; i < num_globs; i++) {
       GlobResult* gr = new GlobResult;
       globs_.push_back(gr);
@@ -243,7 +243,7 @@ class StampChecker {
       LOAD_STRING(fp, &sr->cmd);
       LOAD_STRING(fp, &sr->result);
 
-      string file;
+      std::string file;
       // Ignore debug info
       LOAD_STRING(fp, &file);
       LOAD_INT(fp);
@@ -276,7 +276,7 @@ class StampChecker {
     return needs_regen_;
   }
 
-  bool CheckGlobResult(const GlobResult* gr, string* err) {
+  bool CheckGlobResult(const GlobResult* gr, std::string* err) {
     COLLECT_STATS("glob time (regen)");
     const auto& files = Glob(gr->pat.c_str());
     bool needs_regen = files.size() != gr->result.size();
@@ -312,15 +312,15 @@ class StampChecker {
       return true;
 
     COLLECT_STATS("stat time (regen)");
-    for (const string& dir : sr->missing_dirs) {
+    for (const std::string& dir : sr->missing_dirs) {
       if (Exists(dir))
         return true;
     }
-    for (const string& file : sr->files) {
+    for (const std::string& file : sr->files) {
       if (!Exists(file))
         return true;
     }
-    for (const string& dir : sr->read_dirs) {
+    for (const std::string& dir : sr->read_dirs) {
       // We assume we rarely do a significant change for the top
       // directory which affects the results of find command.
       if (dir == "" || dir == "." || ShouldIgnoreDirty(dir))
@@ -343,7 +343,7 @@ class StampChecker {
     return false;
   }
 
-  bool CheckShellResult(const ShellResult* sr, string* err) {
+  bool CheckShellResult(const ShellResult* sr, std::string* err) {
     if (sr->op == CommandOp::READ_MISSING) {
       if (Exists(sr->cmd)) {
         if (g_flags.dump_kati_stamp)
@@ -407,7 +407,7 @@ class StampChecker {
     }
 
     COLLECT_STATS_WITH_SLOW_REPORT("shell time (regen)", sr->cmd.c_str());
-    string result;
+    std::string result;
     RunCommand(sr->shell, sr->shellflag, sr->cmd, RedirectStderr::DEV_NULL,
                &result);
     FormatForCommandSubstitution(&result);
@@ -428,12 +428,12 @@ class StampChecker {
 
   bool CheckStep2() {
     auto glob_future = std::async([this]() {
-      string err;
+      std::string err;
       // TODO: Make glob cache thread safe and create a task for each glob.
       SetAffinityForSingleThread();
       for (GlobResult* gr : globs_) {
         if (CheckGlobResult(gr, &err)) {
-          unique_lock<mutex> lock(mu_);
+          std::unique_lock<std::mutex> lock(mu_);
           if (!needs_regen_) {
             needs_regen_ = true;
             msg_ = err;
@@ -446,9 +446,9 @@ class StampChecker {
     auto shell_future = std::async([this]() {
       SetAffinityForSingleThread();
       for (ShellResult* sr : commands_) {
-        string err;
+        std::string err;
         if (CheckShellResult(sr, &err)) {
-          unique_lock<mutex> lock(mu_);
+          std::unique_lock<std::mutex> lock(mu_);
           if (!needs_regen_) {
             needs_regen_ = true;
             msg_ = err;
@@ -467,15 +467,15 @@ class StampChecker {
 
  private:
   double gen_time_;
-  vector<GlobResult*> globs_;
-  vector<ShellResult*> commands_;
-  mutex mu_;
+  std::vector<GlobResult*> globs_;
+  std::vector<ShellResult*> commands_;
+  std::mutex mu_;
   bool needs_regen_;
-  string msg_;
+  std::string msg_;
 };
 
 }  // namespace
 
-bool NeedsRegen(double start_time, const string& orig_args) {
+bool NeedsRegen(double start_time, const std::string& orig_args) {
   return StampChecker().NeedsRegen(start_time, orig_args);
 }
diff --git a/src/regen.h b/src/regen.h
index 3d43d70..91f67f1 100644
--- a/src/regen.h
+++ b/src/regen.h
@@ -17,8 +17,6 @@
 
 #include <string>
 
-using namespace std;
-
-bool NeedsRegen(double start_time, const string& orig_args);
+bool NeedsRegen(double start_time, const std::string& orig_args);
 
 #endif  // REGEN_H_
diff --git a/src/regen_dump.cc b/src/regen_dump.cc
index 13ab8be..5ee0159 100644
--- a/src/regen_dump.cc
+++ b/src/regen_dump.cc
@@ -29,12 +29,12 @@
 #include "log.h"
 #include "strutil.h"
 
-vector<string> LoadVecString(FILE* fp) {
+vector<std::string> LoadVecString(FILE* fp) {
   int count = LoadInt(fp);
   if (count < 0) {
     ERROR("Incomplete stamp file");
   }
-  vector<string> ret(count);
+  std::vector<std::string> ret(count);
   for (int i = 0; i < count; i++) {
     if (!LoadString(fp, &ret[i])) {
       ERROR("Incomplete stamp file");
diff --git a/src/rule.cc b/src/rule.cc
index 867a7e3..07116d2 100644
--- a/src/rule.cc
+++ b/src/rule.cc
@@ -47,7 +47,7 @@ void Rule::ParsePrerequisites(const StringPiece& line,
   // First, separate command. At this point separator_pos should point to ';'
   // unless null.
   StringPiece prereq_string = line;
-  if (separator_pos != string::npos &&
+  if (separator_pos != std::string::npos &&
       rule_stmt->sep != RuleStmt::SEP_SEMICOLON) {
     CHECK(line[separator_pos] == ';');
     // TODO: Maybe better to avoid Intern here?
@@ -56,7 +56,7 @@ void Rule::ParsePrerequisites(const StringPiece& line,
     prereq_string = line.substr(0, separator_pos);
   }
 
-  if ((separator_pos = prereq_string.find(':')) == string::npos) {
+  if ((separator_pos = prereq_string.find(':')) == std::string::npos) {
     // Simple prerequisites
     ParseInputs(prereq_string);
     return;
@@ -99,8 +99,8 @@ void Rule::ParsePrerequisites(const StringPiece& line,
   ParseInputs(prereq_patterns);
 }
 
-string Rule::DebugString() const {
-  vector<string> v;
+std::string Rule::DebugString() const {
+  std::vector<std::string> v;
   v.push_back(StringPrintf("outputs=[%s]", JoinSymbols(outputs, ",").c_str()));
   v.push_back(StringPrintf("inputs=[%s]", JoinSymbols(inputs, ",").c_str()));
   if (!order_only_inputs.empty()) {
diff --git a/src/rule.h b/src/rule.h
index 237eb02..bbf5d45 100644
--- a/src/rule.h
+++ b/src/rule.h
@@ -25,8 +25,6 @@
 #include "string_piece.h"
 #include "symtab.h"
 
-using namespace std;
-
 class Value;
 
 class Rule {
@@ -35,7 +33,7 @@ class Rule {
 
   Loc cmd_loc() const { return Loc(loc.filename, cmd_lineno); }
 
-  string DebugString() const;
+  std::string DebugString() const;
 
   void ParseInputs(const StringPiece& inputs_string);
 
@@ -44,22 +42,22 @@ class Rule {
                           const RuleStmt* rule_stmt);
 
   static bool IsPatternRule(const StringPiece& target_string) {
-    return target_string.find('%') != string::npos;
+    return target_string.find('%') != std::string::npos;
   }
 
-  vector<Symbol> outputs;
-  vector<Symbol> inputs;
-  vector<Symbol> order_only_inputs;
-  vector<Symbol> output_patterns;
-  vector<Symbol> validations;
+  std::vector<Symbol> outputs;
+  std::vector<Symbol> inputs;
+  std::vector<Symbol> order_only_inputs;
+  std::vector<Symbol> output_patterns;
+  std::vector<Symbol> validations;
   bool is_double_colon;
   bool is_suffix_rule;
-  vector<Value*> cmds;
+  std::vector<Value*> cmds;
   Loc loc;
   int cmd_lineno;
 
  private:
-  void Error(const string& msg) { ERROR_LOC(loc, "%s", msg.c_str()); }
+  void Error(const std::string& msg) { ERROR_LOC(loc, "%s", msg.c_str()); }
 };
 
 #endif  // RULE_H_
diff --git a/src/stats.cc b/src/stats.cc
index be03774..6dccf7d 100644
--- a/src/stats.cc
+++ b/src/stats.cc
@@ -28,31 +28,31 @@
 
 namespace {
 
-mutex g_mu;
-vector<Stats*>* g_stats;
+std::mutex g_mu;
+std::vector<Stats*>* g_stats;
 
 }  // namespace
 
 Stats::Stats(const char* name) : name_(name), elapsed_(0), cnt_(0) {
-  unique_lock<mutex> lock(g_mu);
+  std::unique_lock<std::mutex> lock(g_mu);
   if (g_stats == NULL)
-    g_stats = new vector<Stats*>;
+    g_stats = new std::vector<Stats*>;
   g_stats->push_back(this);
 }
 
 void Stats::DumpTop() const {
-  unique_lock<mutex> lock(mu_);
+  std::unique_lock<std::mutex> lock(mu_);
   if (detailed_.size() > 0) {
-    vector<pair<string, StatsDetails>> details(detailed_.begin(),
-                                               detailed_.end());
+    std::vector<std::pair<std::string, StatsDetails>> details(detailed_.begin(),
+                                                              detailed_.end());
     sort(details.begin(), details.end(),
-         [](const pair<string, StatsDetails> a,
-            const pair<string, StatsDetails> b) -> bool {
+         [](const std::pair<std::string, StatsDetails> a,
+            const std::pair<std::string, StatsDetails> b) -> bool {
            return a.second.elapsed_ > b.second.elapsed_;
          });
 
     // Only print the top 10
-    details.resize(min(details.size(), static_cast<size_t>(10)));
+    details.resize(std::min(details.size(), static_cast<size_t>(10)));
 
     if (!interesting_.empty()) {
       // No need to print anything out twice
@@ -73,8 +73,8 @@ void Stats::DumpTop() const {
 
     int max_cnt_len = 1;
     for (auto& [name, detail] : details) {
-      max_cnt_len =
-          max(max_cnt_len, static_cast<int>(to_string(detail.cnt_).length()));
+      max_cnt_len = std::max(
+          max_cnt_len, static_cast<int>(std::to_string(detail.cnt_).length()));
     }
 
     for (auto& [name, detail] : details) {
@@ -84,8 +84,8 @@ void Stats::DumpTop() const {
   }
 }
 
-string Stats::String() const {
-  unique_lock<mutex> lock(mu_);
+std::string Stats::String() const {
+  std::unique_lock<std::mutex> lock(mu_);
   if (!detailed_.empty())
     return StringPrintf("%s: %f / %d (%d unique)", name_, elapsed_, cnt_,
                         detailed_.size());
@@ -94,25 +94,25 @@ string Stats::String() const {
 
 double Stats::Start() {
   double start = GetTime();
-  unique_lock<mutex> lock(mu_);
+  std::unique_lock<std::mutex> lock(mu_);
   cnt_++;
   return start;
 }
 
 double Stats::End(double start, const char* msg) {
   double e = GetTime() - start;
-  unique_lock<mutex> lock(mu_);
+  std::unique_lock<std::mutex> lock(mu_);
   elapsed_ += e;
   if (msg != 0) {
-    StatsDetails& details = detailed_[string(msg)];
+    StatsDetails& details = detailed_[std::string(msg)];
     details.elapsed_ += e;
     details.cnt_++;
   }
   return e;
 }
 
-void Stats::MarkInteresting(const string& msg) {
-  unique_lock<mutex> lock(mu_);
+void Stats::MarkInteresting(const std::string& msg) {
+  std::unique_lock<std::mutex> lock(mu_);
   interesting_.emplace(msg);
 }
 
diff --git a/src/stats.h b/src/stats.h
index 4501353..2c311f0 100644
--- a/src/stats.h
+++ b/src/stats.h
@@ -20,8 +20,6 @@
 #include <unordered_map>
 #include <unordered_set>
 
-using namespace std;
-
 struct StatsDetails {
   int cnt_ = 0;
   double elapsed_ = 0;
@@ -32,9 +30,9 @@ class Stats {
   explicit Stats(const char* name);
 
   void DumpTop() const;
-  string String() const;
+  std::string String() const;
 
-  void MarkInteresting(const string& msg);
+  void MarkInteresting(const std::string& msg);
 
  private:
   double Start();
@@ -45,9 +43,9 @@ class Stats {
   const char* name_;
   double elapsed_;
   int cnt_;
-  mutable mutex mu_;
-  unordered_map<string, StatsDetails> detailed_;
-  unordered_set<string> interesting_;
+  mutable std::mutex mu_;
+  std::unordered_map<std::string, StatsDetails> detailed_;
+  std::unordered_set<std::string> interesting_;
 };
 
 class ScopedStatsRecorder {
diff --git a/src/stmt.cc b/src/stmt.cc
index 7315dc1..bdc3406 100644
--- a/src/stmt.cc
+++ b/src/stmt.cc
@@ -30,13 +30,13 @@ void Stmt::Eval(Evaluator* ev) const {
   EvalStatement(ev);
 }
 
-string RuleStmt::DebugString() const {
+std::string RuleStmt::DebugString() const {
   return StringPrintf("RuleStmt(lhs=%s sep=%d rhs=%s loc=%s:%d)",
                       Value::DebugString(lhs).c_str(), sep,
                       Value::DebugString(rhs).c_str(), LOCF(loc()));
 }
 
-string AssignStmt::DebugString() const {
+std::string AssignStmt::DebugString() const {
   const char* opstr = "???";
   switch (op) {
     case AssignOp::EQ:
@@ -73,7 +73,7 @@ string AssignStmt::DebugString() const {
 
 Symbol AssignStmt::GetLhsSymbol(Evaluator* ev) const {
   if (!lhs->IsLiteral()) {
-    string buf;
+    std::string buf;
     lhs->Eval(ev, &buf);
     return Intern(buf);
   }
@@ -84,12 +84,12 @@ Symbol AssignStmt::GetLhsSymbol(Evaluator* ev) const {
   return lhs_sym_cache_;
 }
 
-string CommandStmt::DebugString() const {
+std::string CommandStmt::DebugString() const {
   return StringPrintf("CommandStmt(%s, loc=%s:%d)",
                       Value::DebugString(expr).c_str(), LOCF(loc()));
 }
 
-string IfStmt::DebugString() const {
+std::string IfStmt::DebugString() const {
   const char* opstr = "???";
   switch (op) {
     case CondOp::IFEQ:
@@ -111,17 +111,17 @@ string IfStmt::DebugString() const {
                       false_stmts.size(), LOCF(loc()));
 }
 
-string IncludeStmt::DebugString() const {
+std::string IncludeStmt::DebugString() const {
   return StringPrintf("IncludeStmt(%s, loc=%s:%d)",
                       Value::DebugString(expr).c_str(), LOCF(loc()));
 }
 
-string ExportStmt::DebugString() const {
+std::string ExportStmt::DebugString() const {
   return StringPrintf("ExportStmt(%s, %d, loc=%s:%d)",
                       Value::DebugString(expr).c_str(), is_export, LOCF(loc()));
 }
 
-string ParseErrorStmt::DebugString() const {
+std::string ParseErrorStmt::DebugString() const {
   return StringPrintf("ParseErrorStmt(%s, loc=%s:%d)", msg.c_str(),
                       LOCF(loc()));
 }
diff --git a/src/stmt.h b/src/stmt.h
index d0ef79b..1e96abc 100644
--- a/src/stmt.h
+++ b/src/stmt.h
@@ -22,8 +22,6 @@
 #include "string_piece.h"
 #include "symtab.h"
 
-using namespace std;
-
 class Evaluator;
 class Value;
 
@@ -58,7 +56,7 @@ struct Stmt {
   void Eval(Evaluator*) const;
   virtual void EvalStatement(Evaluator* ev) const = 0;
 
-  virtual string DebugString() const = 0;
+  virtual std::string DebugString() const = 0;
 
  protected:
   Stmt();
@@ -84,7 +82,7 @@ struct RuleStmt : public Stmt {
 
   virtual void EvalStatement(Evaluator* ev) const;
 
-  virtual string DebugString() const;
+  virtual std::string DebugString() const;
 };
 
 struct AssignStmt : public Stmt {
@@ -100,7 +98,7 @@ struct AssignStmt : public Stmt {
 
   virtual void EvalStatement(Evaluator* ev) const;
 
-  virtual string DebugString() const;
+  virtual std::string DebugString() const;
 
   Symbol GetLhsSymbol(Evaluator* ev) const;
 
@@ -116,21 +114,21 @@ struct CommandStmt : public Stmt {
 
   virtual void EvalStatement(Evaluator* ev) const;
 
-  virtual string DebugString() const;
+  virtual std::string DebugString() const;
 };
 
 struct IfStmt : public Stmt {
   CondOp op;
   Value* lhs;
   Value* rhs;
-  vector<Stmt*> true_stmts;
-  vector<Stmt*> false_stmts;
+  std::vector<Stmt*> true_stmts;
+  std::vector<Stmt*> false_stmts;
 
   virtual ~IfStmt();
 
   virtual void EvalStatement(Evaluator* ev) const;
 
-  virtual string DebugString() const;
+  virtual std::string DebugString() const;
 };
 
 struct IncludeStmt : public Stmt {
@@ -141,7 +139,7 @@ struct IncludeStmt : public Stmt {
 
   virtual void EvalStatement(Evaluator* ev) const;
 
-  virtual string DebugString() const;
+  virtual std::string DebugString() const;
 };
 
 struct ExportStmt : public Stmt {
@@ -152,17 +150,17 @@ struct ExportStmt : public Stmt {
 
   virtual void EvalStatement(Evaluator* ev) const;
 
-  virtual string DebugString() const;
+  virtual std::string DebugString() const;
 };
 
 struct ParseErrorStmt : public Stmt {
-  string msg;
+  std::string msg;
 
   virtual ~ParseErrorStmt();
 
   virtual void EvalStatement(Evaluator* ev) const;
 
-  virtual string DebugString() const;
+  virtual std::string DebugString() const;
 };
 
 #endif  // STMT_H_
diff --git a/src/string_piece_test.cc b/src/string_piece_test.cc
index 0434cbe..275615f 100644
--- a/src/string_piece_test.cc
+++ b/src/string_piece_test.cc
@@ -20,10 +20,8 @@
 
 #include <unordered_set>
 
-using namespace std;
-
 int main() {
-  unordered_set<StringPiece> sps;
+  std::unordered_set<StringPiece> sps;
   sps.insert(StringPiece("foo"));
   sps.insert(StringPiece("foo"));
   sps.insert(StringPiece("bar"));
diff --git a/src/stringprintf.cc b/src/stringprintf.cc
index b0d4b4a..c16ca18 100644
--- a/src/stringprintf.cc
+++ b/src/stringprintf.cc
@@ -19,8 +19,8 @@
 #include <assert.h>
 #include <stdarg.h>
 
-string StringPrintf(const char* format, ...) {
-  string str;
+std::string StringPrintf(const char* format, ...) {
+  std::string str;
   str.resize(128);
   for (int i = 0; i < 2; i++) {
     va_list args;
diff --git a/src/stringprintf.h b/src/stringprintf.h
index 8b67e6c..d7e10a9 100644
--- a/src/stringprintf.h
+++ b/src/stringprintf.h
@@ -17,8 +17,6 @@
 
 #include <string>
 
-using namespace std;
-
-string StringPrintf(const char* fmt, ...);
+std::string StringPrintf(const char* fmt, ...);
 
 #endif  // STRINGPRINTF_H_
diff --git a/src/strutil.cc b/src/strutil.cc
index 4546265..5d89241 100644
--- a/src/strutil.cc
+++ b/src/strutil.cc
@@ -76,12 +76,12 @@ WordScanner::Iterator WordScanner::end() const {
   return iter;
 }
 
-void WordScanner::Split(vector<StringPiece>* o) {
+void WordScanner::Split(std::vector<StringPiece>* o) {
   for (StringPiece t : *this)
     o->push_back(t);
 }
 
-WordWriter::WordWriter(string* o) : out_(o), needs_space_(false) {}
+WordWriter::WordWriter(std::string* o) : out_(o), needs_space_(false) {}
 
 void WordWriter::MaybeAddWhitespace() {
   if (needs_space_) {
@@ -104,7 +104,7 @@ ScopedTerminator::~ScopedTerminator() {
   const_cast<char*>(s_.data())[s_.size()] = c_;
 }
 
-void AppendString(StringPiece str, string* out) {
+void AppendString(StringPiece str, std::string* out) {
   out->append(str.begin(), str.end());
 }
 
@@ -120,7 +120,7 @@ bool HasSuffix(StringPiece str, StringPiece suffix) {
 
 bool HasWord(StringPiece str, StringPiece w) {
   size_t found = str.find(w);
-  if (found == string::npos)
+  if (found == std::string::npos)
     return false;
   if (found != 0 && !isSpace(str[found - 1]))
     return false;
@@ -147,7 +147,7 @@ StringPiece TrimSuffix(StringPiece str, StringPiece suffix) {
 Pattern::Pattern(StringPiece pat) : pat_(pat), percent_index_(pat.find('%')) {}
 
 bool Pattern::Match(StringPiece str) const {
-  if (percent_index_ == string::npos)
+  if (percent_index_ == std::string::npos)
     return str == pat_;
   return MatchImpl(str);
 }
@@ -165,8 +165,8 @@ StringPiece Pattern::Stem(StringPiece str) const {
 
 void Pattern::AppendSubst(StringPiece str,
                           StringPiece subst,
-                          string* out) const {
-  if (percent_index_ == string::npos) {
+                          std::string* out) const {
+  if (percent_index_ == std::string::npos) {
     if (str == pat_) {
       AppendString(subst, out);
       return;
@@ -178,7 +178,7 @@ void Pattern::AppendSubst(StringPiece str,
 
   if (MatchImpl(str)) {
     size_t subst_percent_index = subst.find('%');
-    if (subst_percent_index == string::npos) {
+    if (subst_percent_index == std::string::npos) {
       AppendString(subst, out);
       return;
     } else {
@@ -194,8 +194,9 @@ void Pattern::AppendSubst(StringPiece str,
 
 void Pattern::AppendSubstRef(StringPiece str,
                              StringPiece subst,
-                             string* out) const {
-  if (percent_index_ != string::npos && subst.find('%') != string::npos) {
+                             std::string* out) const {
+  if (percent_index_ != std::string::npos &&
+      subst.find('%') != std::string::npos) {
     AppendSubst(str, subst, out);
     return;
   }
@@ -204,12 +205,12 @@ void Pattern::AppendSubstRef(StringPiece str,
   out->append(subst.begin(), subst.end());
 }
 
-string NoLineBreak(const string& s) {
+std::string NoLineBreak(const std::string& s) {
   size_t index = s.find('\n');
-  if (index == string::npos)
+  if (index == std::string::npos)
     return s;
-  string r = s;
-  while (index != string::npos) {
+  std::string r = s;
+  while (index != std::string::npos) {
     r = r.substr(0, index) + "\\n" + r.substr(index + 1);
     index = r.find('\n', index + 2);
   }
@@ -251,7 +252,7 @@ StringPiece TrimSpace(StringPiece s) {
 
 StringPiece Dirname(StringPiece s) {
   size_t found = s.rfind('/');
-  if (found == string::npos)
+  if (found == std::string::npos)
     return StringPiece(".");
   if (found == 0)
     return StringPiece("");
@@ -260,14 +261,14 @@ StringPiece Dirname(StringPiece s) {
 
 StringPiece Basename(StringPiece s) {
   size_t found = s.rfind('/');
-  if (found == string::npos || found == 0)
+  if (found == std::string::npos || found == 0)
     return s;
   return s.substr(found + 1);
 }
 
 StringPiece GetExt(StringPiece s) {
   size_t found = s.rfind('.');
-  if (found == string::npos)
+  if (found == std::string::npos)
     return StringPiece("");
   return s.substr(found);
 }
@@ -275,13 +276,13 @@ StringPiece GetExt(StringPiece s) {
 StringPiece StripExt(StringPiece s) {
   size_t slash_index = s.rfind('/');
   size_t found = s.rfind('.');
-  if (found == string::npos ||
-      (slash_index != string::npos && found < slash_index))
+  if (found == std::string::npos ||
+      (slash_index != std::string::npos && found < slash_index))
     return s;
   return s.substr(0, found);
 }
 
-void NormalizePath(string* o) {
+void NormalizePath(std::string* o) {
   if (o->empty())
     return;
   size_t start_index = 0;
@@ -308,7 +309,7 @@ void NormalizePath(string* o) {
         size_t orig_j = j;
         j -= 4;
         j = o->rfind('/', j);
-        if (j == string::npos) {
+        if (j == std::string::npos) {
           j = start_index;
         } else {
           j++;
@@ -332,7 +333,7 @@ void NormalizePath(string* o) {
   o->resize(j);
 }
 
-void AbsPath(StringPiece s, string* o) {
+void AbsPath(StringPiece s, std::string* o) {
   if (s.get(0) == '/') {
     o->clear();
   } else {
@@ -353,7 +354,7 @@ void AbsPath(StringPiece s, string* o) {
 template <typename Cond>
 size_t FindOutsideParenImpl(StringPiece s, Cond cond) {
   bool prev_backslash = false;
-  stack<char> paren_stack;
+  std::stack<char> paren_stack;
   for (size_t i = 0; i < s.size(); i++) {
     char c = s[i];
     if (cond(c) && paren_stack.empty() && !prev_backslash) {
@@ -376,7 +377,7 @@ size_t FindOutsideParenImpl(StringPiece s, Cond cond) {
     }
     prev_backslash = c == '\\' && !prev_backslash;
   }
-  return string::npos;
+  return std::string::npos;
 }
 
 size_t FindOutsideParen(StringPiece s, char c) {
@@ -429,7 +430,7 @@ StringPiece TrimLeadingCurdir(StringPiece s) {
   return s;
 }
 
-void FormatForCommandSubstitution(string* s) {
+void FormatForCommandSubstitution(std::string* s) {
   while ((*s)[s->size() - 1] == '\n')
     s->pop_back();
   for (size_t i = 0; i < s->size(); i++) {
@@ -438,8 +439,8 @@ void FormatForCommandSubstitution(string* s) {
   }
 }
 
-string SortWordsInString(StringPiece s) {
-  vector<string> toks;
+std::string SortWordsInString(StringPiece s) {
+  std::vector<std::string> toks;
   for (StringPiece tok : WordScanner(s)) {
     toks.push_back(tok.as_string());
   }
@@ -447,8 +448,8 @@ string SortWordsInString(StringPiece s) {
   return JoinStrings(toks, " ");
 }
 
-string ConcatDir(StringPiece b, StringPiece n) {
-  string r;
+std::string ConcatDir(StringPiece b, StringPiece n) {
+  std::string r;
   if (!b.empty() && (n.empty() || n[0] != '/')) {
     b.AppendToString(&r);
     r += '/';
@@ -458,9 +459,9 @@ string ConcatDir(StringPiece b, StringPiece n) {
   return r;
 }
 
-string EchoEscape(const string& str) {
+std::string EchoEscape(const std::string& str) {
   const char* in = str.c_str();
-  string buf;
+  std::string buf;
   for (; *in; in++) {
     switch (*in) {
       case '\\':
@@ -479,14 +480,14 @@ string EchoEscape(const string& str) {
   return buf;
 }
 
-void EscapeShell(string* s) {
+void EscapeShell(std::string* s) {
   static const char delimiters[] = "\"$\\`";
   size_t prev = 0;
   size_t i = SkipUntil(s->c_str(), s->size(), delimiters);
   if (i == s->size())
     return;
 
-  string r;
+  std::string r;
   for (; i < s->size();) {
     StringPiece(*s).substr(prev, i - prev).AppendToString(&r);
     char c = (*s)[i];
diff --git a/src/strutil.h b/src/strutil.h
index d573b79..c5b961f 100644
--- a/src/strutil.h
+++ b/src/strutil.h
@@ -20,8 +20,6 @@
 
 #include "string_piece.h"
 
-using namespace std;
-
 class WordScanner {
  public:
   struct Iterator {
@@ -41,7 +39,7 @@ class WordScanner {
   Iterator begin() const;
   Iterator end() const;
 
-  void Split(vector<StringPiece>* o);
+  void Split(std::vector<StringPiece>* o);
 
  private:
   StringPiece in_;
@@ -49,12 +47,12 @@ class WordScanner {
 
 class WordWriter {
  public:
-  explicit WordWriter(string* o);
+  explicit WordWriter(std::string* o);
   void MaybeAddWhitespace();
   void Write(StringPiece s);
 
  private:
-  string* out_;
+  std::string* out_;
   bool needs_space_;
 };
 
@@ -70,8 +68,8 @@ class ScopedTerminator {
 };
 
 template <class String>
-inline string JoinStrings(vector<String> v, const char* sep) {
-  string r;
+inline std::string JoinStrings(std::vector<String> v, const char* sep) {
+  std::string r;
   for (StringPiece s : v) {
     if (!r.empty()) {
       r += sep;
@@ -81,7 +79,7 @@ inline string JoinStrings(vector<String> v, const char* sep) {
   return r;
 }
 
-void AppendString(StringPiece str, string* out);
+void AppendString(StringPiece str, std::string* out);
 
 bool HasPrefix(StringPiece str, StringPiece prefix);
 
@@ -101,9 +99,11 @@ class Pattern {
 
   StringPiece Stem(StringPiece str) const;
 
-  void AppendSubst(StringPiece str, StringPiece subst, string* out) const;
+  void AppendSubst(StringPiece str, StringPiece subst, std::string* out) const;
 
-  void AppendSubstRef(StringPiece str, StringPiece subst, string* out) const;
+  void AppendSubstRef(StringPiece str,
+                      StringPiece subst,
+                      std::string* out) const;
 
  private:
   bool MatchImpl(StringPiece str) const;
@@ -112,7 +112,7 @@ class Pattern {
   size_t percent_index_;
 };
 
-string NoLineBreak(const string& s);
+std::string NoLineBreak(const std::string& s);
 
 StringPiece TrimLeftSpace(StringPiece s);
 StringPiece TrimRightSpace(StringPiece s);
@@ -122,8 +122,8 @@ StringPiece Dirname(StringPiece s);
 StringPiece Basename(StringPiece s);
 StringPiece GetExt(StringPiece s);
 StringPiece StripExt(StringPiece s);
-void NormalizePath(string* o);
-void AbsPath(StringPiece s, string* o);
+void NormalizePath(std::string* o);
+void AbsPath(StringPiece s, std::string* o);
 
 size_t FindOutsideParen(StringPiece s, char c);
 size_t FindTwoOutsideParen(StringPiece s, char c1, char c2);
@@ -136,15 +136,15 @@ size_t FindEndOfLine(StringPiece s, size_t e, size_t* lf_cnt);
 // From http://www.gnu.org/software/make/manual/make.html#Features
 StringPiece TrimLeadingCurdir(StringPiece s);
 
-void FormatForCommandSubstitution(string* s);
+void FormatForCommandSubstitution(std::string* s);
 
-string SortWordsInString(StringPiece s);
+std::string SortWordsInString(StringPiece s);
 
-string ConcatDir(StringPiece b, StringPiece n);
+std::string ConcatDir(StringPiece b, StringPiece n);
 
-string EchoEscape(const string& str);
+std::string EchoEscape(const std::string& str);
 
-void EscapeShell(string* s);
+void EscapeShell(std::string* s);
 
 bool IsInteger(StringPiece s);
 
diff --git a/src/strutil_bench.cc b/src/strutil_bench.cc
index d3b2e6c..f49bf7a 100644
--- a/src/strutil_bench.cc
+++ b/src/strutil_bench.cc
@@ -22,11 +22,9 @@
 #include "strutil.h"
 #include "timeutil.h"
 
-using namespace std;
-
 int main() {
   g_flags.enable_stat_logs = true;
-  string s;
+  std::string s;
   while (s.size() < 400000) {
     if (!s.empty())
       s += ' ';
@@ -36,7 +34,7 @@ int main() {
   ScopedTimeReporter tr("WordScanner");
   static const int N = 1000;
   for (int i = 0; i < N; i++) {
-    vector<StringPiece> toks;
+    std::vector<StringPiece> toks;
     WordScanner(s).Split(&toks);
   }
 }
diff --git a/src/strutil_test.cc b/src/strutil_test.cc
index d95d351..1209202 100644
--- a/src/strutil_test.cc
+++ b/src/strutil_test.cc
@@ -26,12 +26,10 @@
 #include "string_piece.h"
 #include "testutil.h"
 
-using namespace std;
-
 namespace {
 
 void TestWordScanner() {
-  vector<StringPiece> ss;
+  std::vector<StringPiece> ss;
   for (StringPiece tok : WordScanner("foo bar baz hogeeeeeeeeeeeeeeee")) {
     ss.push_back(tok);
   }
@@ -70,8 +68,8 @@ void TestTrimSuffix() {
   ASSERT_EQ(TrimSuffix("bar", "bbar"), "bar");
 }
 
-string SubstPattern(StringPiece str, StringPiece pat, StringPiece subst) {
-  string r;
+std::string SubstPattern(StringPiece str, StringPiece pat, StringPiece subst) {
+  std::string r;
   Pattern(pat).AppendSubst(str, subst, &r);
   return r;
 }
@@ -104,7 +102,7 @@ void TestHasWord() {
   assert(!HasWord("foo bar baz", "fo"));
 }
 
-static string NormalizePath(string s) {
+static std::string NormalizePath(std::string s) {
   ::NormalizePath(&s);
   return s;
 }
@@ -132,7 +130,7 @@ void TestNormalizePath() {
   ASSERT_EQ(NormalizePath("./../../a/b"), "../../a/b");
 }
 
-string EscapeShell(string s) {
+std::string EscapeShell(std::string s) {
   ::EscapeShell(&s);
   return s;
 }
@@ -184,7 +182,7 @@ const char* CreateProtectedString(const char* str) {
 }
 
 void TestWordScannerInvalidAccess() {
-  vector<StringPiece> ss;
+  std::vector<StringPiece> ss;
   for (StringPiece tok : WordScanner(CreateProtectedString("0123 456789"))) {
     ss.push_back(tok);
   }
diff --git a/src/symtab.cc b/src/symtab.cc
index 69895f7..9c17495 100644
--- a/src/symtab.cc
+++ b/src/symtab.cc
@@ -35,8 +35,8 @@ struct SymbolData {
   Var* gv;
 };
 
-vector<string*>* g_symbols;
-static vector<SymbolData> g_symbol_data;
+std::vector<std::string*>* g_symbols;
+static std::vector<SymbolData> g_symbol_data;
 
 Symbol kEmptySym;
 Symbol kShellSym;
@@ -143,7 +143,7 @@ class Symtab {
 
   ~Symtab() {
     LOG_STAT("%zu symbols", symbols_.size());
-    for (string* s : symbols_)
+    for (std::string* s : symbols_)
       delete s;
   }
 
@@ -152,7 +152,7 @@ class Symtab {
     if (found != symtab_.end()) {
       return found->second;
     }
-    symbols_.push_back(new string(s.data(), s.size()));
+    symbols_.push_back(new std::string(s.data(), s.size()));
     Symbol sym = Symbol(symtab_.size());
     bool ok = symtab_.emplace(*symbols_.back(), sym).second;
     CHECK(ok);
@@ -171,8 +171,9 @@ class Symtab {
     return InternImpl(s);
   }
 
-  vector<StringPiece> GetSymbolNames(std::function<bool(Var*)> const& filter) {
-    vector<StringPiece> result;
+  std::vector<StringPiece> GetSymbolNames(
+      std::function<bool(Var*)> const& filter) {
+    std::vector<StringPiece> result;
     for (auto entry : symtab_) {
       Var* var = entry.second.PeekGlobalVar();
       // The symbol table contains all interned strings, not just variables
@@ -188,8 +189,8 @@ class Symtab {
   }
 
  private:
-  unordered_map<StringPiece, Symbol> symtab_;
-  vector<string*> symbols_;
+  std::unordered_map<StringPiece, Symbol> symtab_;
+  std::vector<std::string*> symbols_;
 #ifdef ENABLE_TID_CHECK
   pthread_t tid_;
 #endif
@@ -201,8 +202,8 @@ Symbol Intern(StringPiece s) {
   return g_symtab.Intern(s);
 }
 
-string JoinSymbols(const vector<Symbol>& syms, const char* sep) {
-  vector<string> strs;
+std::string JoinSymbols(const std::vector<Symbol>& syms, const char* sep) {
+  std::vector<std::string> strs;
   strs.reserve(syms.size());
   for (Symbol s : syms) {
     strs.push_back(s.str());
@@ -210,6 +211,7 @@ string JoinSymbols(const vector<Symbol>& syms, const char* sep) {
   return JoinStrings(strs, sep);
 }
 
-vector<StringPiece> GetSymbolNames(std::function<bool(Var*)> const& filter) {
+std::vector<StringPiece> GetSymbolNames(
+    std::function<bool(Var*)> const& filter) {
   return g_symtab.GetSymbolNames(filter);
 }
diff --git a/src/symtab.h b/src/symtab.h
index f3524ca..137b8ef 100644
--- a/src/symtab.h
+++ b/src/symtab.h
@@ -22,9 +22,7 @@
 
 #include "string_piece.h"
 
-using namespace std;
-
-extern vector<string*>* g_symbols;
+extern std::vector<std::string*>* g_symbols;
 
 class Symtab;
 class Var;
@@ -33,7 +31,7 @@ class Symbol {
  public:
   explicit Symbol() : v_(-1) {}
 
-  const string& str() const { return *((*g_symbols)[v_]); }
+  const std::string& str() const { return *((*g_symbols)[v_]); }
 
   const char* c_str() const { return str().c_str(); }
 
@@ -42,7 +40,7 @@ class Symbol {
   int val() const { return v_; }
 
   char get(size_t i) const {
-    const string& s = str();
+    const std::string& s = str();
     if (i >= s.size())
       return 0;
     return s[i];
@@ -223,9 +221,10 @@ extern Symbol kKatiReadonlySym;
 
 Symbol Intern(StringPiece s);
 
-string JoinSymbols(const vector<Symbol>& syms, const char* sep);
+std::string JoinSymbols(const std::vector<Symbol>& syms, const char* sep);
 
 // Get all symbol names for which filter returns true.
-vector<StringPiece> GetSymbolNames(std::function<bool(Var*)> const& filter);
+std::vector<StringPiece> GetSymbolNames(
+    std::function<bool(Var*)> const& filter);
 
 #endif  // SYMTAB_H_
diff --git a/src/var.cc b/src/var.cc
index e51aa6b..93b340a 100644
--- a/src/var.cc
+++ b/src/var.cc
@@ -21,7 +21,7 @@
 #include "log.h"
 #include "strutil.h"
 
-unordered_map<const Var*, string> Var::diagnostic_messages_;
+std::unordered_map<const Var*, std::string> Var::diagnostic_messages_;
 
 const char* GetOriginStr(VarOrigin origin) {
   switch (origin) {
@@ -90,8 +90,8 @@ const char* Var::diagnostic_message_text() const {
   return it == diagnostic_messages_.end() ? "" : it->second.c_str();
 }
 
-const string& Var::DeprecatedMessage() const {
-  static const string empty_string;
+const std::string& Var::DeprecatedMessage() const {
+  static const std::string empty_string;
   auto it = diagnostic_messages_.find(this);
   return it == diagnostic_messages_.end() ? empty_string : it->second;
 }
@@ -107,7 +107,7 @@ Var* Var::Undefined() {
 SimpleVar::SimpleVar(VarOrigin origin, Frame* definition, Loc loc)
     : Var(origin, definition, loc) {}
 
-SimpleVar::SimpleVar(const string& v,
+SimpleVar::SimpleVar(const std::string& v,
                      VarOrigin origin,
                      Frame* definition,
                      Loc loc)
@@ -126,13 +126,13 @@ bool SimpleVar::IsFunc(Evaluator*) const {
   return false;
 }
 
-void SimpleVar::Eval(Evaluator* ev, string* s) const {
+void SimpleVar::Eval(Evaluator* ev, std::string* s) const {
   ev->CheckStack();
   *s += v_;
 }
 
 void SimpleVar::AppendVar(Evaluator* ev, Value* v) {
-  string buf;
+  std::string buf;
   v->Eval(ev, &buf);
   v_.push_back(' ');
   v_ += buf;
@@ -143,7 +143,7 @@ StringPiece SimpleVar::String() const {
   return v_;
 }
 
-string SimpleVar::DebugString() const {
+std::string SimpleVar::DebugString() const {
   return v_;
 }
 
@@ -158,7 +158,7 @@ bool RecursiveVar::IsFunc(Evaluator* ev) const {
   return v_->IsFunc(ev);
 }
 
-void RecursiveVar::Eval(Evaluator* ev, string* s) const {
+void RecursiveVar::Eval(Evaluator* ev, std::string* s) const {
   ev->CheckStack();
   v_->Eval(ev, s);
 }
@@ -186,7 +186,7 @@ StringPiece RecursiveVar::String() const {
   return orig_;
 }
 
-string RecursiveVar::DebugString() const {
+std::string RecursiveVar::DebugString() const {
   return Value::DebugString(v_);
 }
 
@@ -196,7 +196,7 @@ bool UndefinedVar::IsFunc(Evaluator*) const {
   return false;
 }
 
-void UndefinedVar::Eval(Evaluator*, string*) const {
+void UndefinedVar::Eval(Evaluator*, std::string*) const {
   // Nothing to do.
 }
 
@@ -204,7 +204,7 @@ StringPiece UndefinedVar::String() const {
   return StringPiece("");
 }
 
-string UndefinedVar::DebugString() const {
+std::string UndefinedVar::DebugString() const {
   return "*undefined*";
 }
 
@@ -218,7 +218,7 @@ bool VariableNamesVar::IsFunc(Evaluator*) const {
   return false;
 }
 
-void VariableNamesVar::Eval(Evaluator* ev, string* s) const {
+void VariableNamesVar::Eval(Evaluator* ev, std::string* s) const {
   ConcatVariableNames(ev, s);
 }
 
@@ -226,9 +226,10 @@ StringPiece VariableNamesVar::String() const {
   return name_;
 }
 
-void VariableNamesVar::ConcatVariableNames(Evaluator* ev, string* s) const {
+void VariableNamesVar::ConcatVariableNames(Evaluator* ev,
+                                           std::string* s) const {
   WordWriter ww(s);
-  vector<StringPiece>&& symbols = GetSymbolNames([=](Var* var) -> bool {
+  std::vector<StringPiece>&& symbols = GetSymbolNames([=](Var* var) -> bool {
     if (var->Obsolete()) {
       return false;
     }
@@ -244,7 +245,7 @@ void VariableNamesVar::ConcatVariableNames(Evaluator* ev, string* s) const {
   }
 }
 
-string VariableNamesVar::DebugString() const {
+std::string VariableNamesVar::DebugString() const {
   return "*VariableNamesVar*";
 }
 
@@ -269,7 +270,7 @@ bool ShellStatusVar::IsFunc(Evaluator*) const {
   return false;
 }
 
-void ShellStatusVar::Eval(Evaluator* ev, string* s) const {
+void ShellStatusVar::Eval(Evaluator* ev, std::string* s) const {
   if (ev->IsEvaluatingCommand()) {
     ev->Error("Kati does not support using .SHELLSTATUS inside of a rule");
   }
@@ -289,7 +290,7 @@ StringPiece ShellStatusVar::String() const {
   return std::to_string(shell_status_);
 }
 
-string ShellStatusVar::DebugString() const {
+std::string ShellStatusVar::DebugString() const {
   return "*ShellStatusVar*";
 }
 
diff --git a/src/var.h b/src/var.h
index 67b26f6..2186460 100644
--- a/src/var.h
+++ b/src/var.h
@@ -28,8 +28,6 @@
 #include "string_piece.h"
 #include "symtab.h"
 
-using namespace std;
-
 class Evaluator;
 class Value;
 
@@ -61,7 +59,7 @@ class Var : public Evaluable {
 
   virtual StringPiece String() const = 0;
 
-  virtual string DebugString() const = 0;
+  virtual std::string DebugString() const = 0;
 
   bool ReadOnly() const { return readonly_; }
   void SetReadOnly() { readonly_ = true; }
@@ -75,7 +73,7 @@ class Var : public Evaluable {
   bool SelfReferential() const { return self_referential_; }
   void SetSelfReferential() { self_referential_ = true; }
 
-  const string& DeprecatedMessage() const;
+  const std::string& DeprecatedMessage() const;
 
   // This variable was used (either written or read from)
   virtual void Used(Evaluator* ev, const Symbol& sym) const;
@@ -102,13 +100,13 @@ class Var : public Evaluable {
 
   const char* diagnostic_message_text() const;
 
-  static unordered_map<const Var*, string> diagnostic_messages_;
+  static std::unordered_map<const Var*, std::string> diagnostic_messages_;
 };
 
 class SimpleVar : public Var {
  public:
   explicit SimpleVar(VarOrigin origin, Frame* definition, Loc loc);
-  SimpleVar(const string& v, VarOrigin origin, Frame* definition, Loc loc);
+  SimpleVar(const std::string& v, VarOrigin origin, Frame* definition, Loc loc);
   SimpleVar(VarOrigin origin,
             Frame* definition,
             Loc loc,
@@ -119,15 +117,15 @@ class SimpleVar : public Var {
 
   virtual bool IsFunc(Evaluator* ev) const override;
 
-  virtual void Eval(Evaluator* ev, string* s) const override;
+  virtual void Eval(Evaluator* ev, std::string* s) const override;
 
   virtual void AppendVar(Evaluator* ev, Value* v) override;
 
   virtual StringPiece String() const override;
 
-  virtual string DebugString() const override;
+  virtual std::string DebugString() const override;
 
-  string v_;
+  std::string v_;
 };
 
 class RecursiveVar : public Var {
@@ -142,13 +140,13 @@ class RecursiveVar : public Var {
 
   virtual bool IsFunc(Evaluator* ev) const override;
 
-  virtual void Eval(Evaluator* ev, string* s) const override;
+  virtual void Eval(Evaluator* ev, std::string* s) const override;
 
   virtual void AppendVar(Evaluator* ev, Value* v) override;
 
   virtual StringPiece String() const override;
 
-  virtual string DebugString() const override;
+  virtual std::string DebugString() const override;
 
   virtual void Used(Evaluator* ev, const Symbol& sym) const override;
 
@@ -165,11 +163,11 @@ class UndefinedVar : public Var {
 
   virtual bool IsFunc(Evaluator* ev) const override;
 
-  virtual void Eval(Evaluator* ev, string* s) const override;
+  virtual void Eval(Evaluator* ev, std::string* s) const override;
 
   virtual StringPiece String() const override;
 
-  virtual string DebugString() const override;
+  virtual std::string DebugString() const override;
 };
 
 // The built-in VARIABLES and KATI_SYMBOLS variables
@@ -182,17 +180,17 @@ class VariableNamesVar : public Var {
 
   virtual bool IsFunc(Evaluator* ev) const override;
 
-  virtual void Eval(Evaluator* ev, string* s) const override;
+  virtual void Eval(Evaluator* ev, std::string* s) const override;
 
   virtual StringPiece String() const override;
 
-  virtual string DebugString() const override;
+  virtual std::string DebugString() const override;
 
  private:
   StringPiece name_;
   bool all_;
 
-  void ConcatVariableNames(Evaluator* ev, string* s) const;
+  void ConcatVariableNames(Evaluator* ev, std::string* s) const;
 };
 
 // The built-in .SHELLSTATUS variable
@@ -207,18 +205,18 @@ class ShellStatusVar : public Var {
 
   virtual bool IsFunc(Evaluator* ev) const override;
 
-  virtual void Eval(Evaluator* ev, string* s) const override;
+  virtual void Eval(Evaluator* ev, std::string* s) const override;
 
   virtual StringPiece String() const override;
 
-  virtual string DebugString() const override;
+  virtual std::string DebugString() const override;
 
  private:
   static bool is_set_;
   static int shell_status_;
 };
 
-class Vars : public unordered_map<Symbol, Var*> {
+class Vars : public std::unordered_map<Symbol, Var*> {
  public:
   ~Vars();