diff --git a/src/gn/err.cc b/src/gn/err.cc
index 68cb046..aeeb921 100644
--- a/src/gn/err.cc
+++ b/src/gn/err.cc
@@ -86,57 +86,59 @@
 
 }  // namespace
 
-Err::Err() : has_error_(false) {}
+Err::Err(const Err& other) {
+  if (other.info_)
+    info_ = std::make_unique<ErrInfo>(*other.info_);
+}
 
 Err::Err(const Location& location,
          const std::string& msg,
          const std::string& help)
-    : has_error_(true), location_(location), message_(msg), help_text_(help) {}
+    : info_(std::make_unique<ErrInfo>(location, msg, help)) {}
 
 Err::Err(const LocationRange& range,
          const std::string& msg,
          const std::string& help)
-    : has_error_(true),
-      location_(range.begin()),
-      message_(msg),
-      help_text_(help) {
-  ranges_.push_back(range);
+    : info_(std::make_unique<ErrInfo>(range.begin(), msg, help)) {
+  info_->ranges.push_back(range);
 }
 
 Err::Err(const Token& token, const std::string& msg, const std::string& help)
-    : has_error_(true),
-      location_(token.location()),
-      message_(msg),
-      help_text_(help) {
-  ranges_.push_back(token.range());
+    : info_(std::make_unique<ErrInfo>(token.location(), msg, help)) {
+  info_->ranges.push_back(token.range());
 }
 
 Err::Err(const ParseNode* node,
          const std::string& msg,
          const std::string& help_text)
-    : has_error_(true), message_(msg), help_text_(help_text) {
+    : info_(std::make_unique<ErrInfo>(Location(), msg, help_text)) {
   // Node will be null in certain tests.
   if (node) {
     LocationRange range = node->GetRange();
-    location_ = range.begin();
-    ranges_.push_back(range);
+    info_->location = range.begin();
+    info_->ranges.push_back(range);
   }
 }
 
 Err::Err(const Value& value,
-         const std::string msg,
+         const std::string& msg,
          const std::string& help_text)
-    : has_error_(true), message_(msg), help_text_(help_text) {
+    : info_(std::make_unique<ErrInfo>(Location(), msg, help_text)) {
   if (value.origin()) {
     LocationRange range = value.origin()->GetRange();
-    location_ = range.begin();
-    ranges_.push_back(range);
+    info_->location = range.begin();
+    info_->ranges.push_back(range);
   }
 }
 
-Err::Err(const Err& other) = default;
-
-Err::~Err() = default;
+Err& Err::operator=(const Err& other) {
+  if (other.info_) {
+    info_ = std::make_unique<ErrInfo>(*other.info_);
+  } else {
+    info_.reset();
+  }
+  return *this;
+}
 
 void Err::PrintToStdout() const {
   InternalPrintToStdout(false, true);
@@ -147,11 +149,11 @@
 }
 
 void Err::AppendSubErr(const Err& err) {
-  sub_errs_.push_back(err);
+  info_->sub_errs.push_back(err);
 }
 
 void Err::InternalPrintToStdout(bool is_sub_err, bool is_fatal) const {
-  DCHECK(has_error_);
+  DCHECK(info_);
 
   if (!is_sub_err) {
     if (is_fatal)
@@ -161,40 +163,40 @@
   }
 
   // File name and location.
-  const InputFile* input_file = location_.file();
-  std::string loc_str = location_.Describe(true);
+  const InputFile* input_file = info_->location.file();
+  std::string loc_str = info_->location.Describe(true);
   if (!loc_str.empty()) {
     if (is_sub_err)
       loc_str.insert(0, "See ");
     else
       loc_str.insert(0, "at ");
-    if (!toolchain_label_.is_null())
+    if (!info_->toolchain_label.is_null())
       loc_str += " ";
   }
   std::string toolchain_str;
-  if (!toolchain_label_.is_null()) {
-    toolchain_str += "(" + toolchain_label_.GetUserVisibleName(false) + ")";
+  if (!info_->toolchain_label.is_null()) {
+    toolchain_str += "(" + info_->toolchain_label.GetUserVisibleName(false) + ")";
   }
   std::string colon;
   if (!loc_str.empty() || !toolchain_str.empty())
     colon = ": ";
-  OutputString(loc_str + toolchain_str + colon + message_ + "\n");
+  OutputString(loc_str + toolchain_str + colon + info_->message + "\n");
 
   // Quoted line.
   if (input_file) {
     std::string line =
-        GetNthLine(input_file->contents(), location_.line_number());
+        GetNthLine(input_file->contents(), info_->location.line_number());
     if (!base::ContainsOnlyChars(line, base::kWhitespaceASCII)) {
       OutputString(line + "\n", DECORATION_DIM);
-      OutputHighlighedPosition(location_, ranges_, line.size());
+      OutputHighlighedPosition(info_->location, info_->ranges, line.size());
     }
   }
 
   // Optional help text.
-  if (!help_text_.empty())
-    OutputString(help_text_ + "\n");
+  if (!info_->help_text.empty())
+    OutputString(info_->help_text + "\n");
 
   // Sub errors.
-  for (const auto& sub_err : sub_errs_)
+  for (const auto& sub_err : info_->sub_errs)
     sub_err.InternalPrintToStdout(true, is_fatal);
 }
diff --git a/src/gn/err.h b/src/gn/err.h
index f9a7d76..efccf0b 100644
--- a/src/gn/err.h
+++ b/src/gn/err.h
@@ -24,11 +24,27 @@
 // An error can also have sub-errors which are additionally printed out
 // below. They can provide additional context.
 class Err {
+ private:
+  struct ErrInfo {
+    ErrInfo(const Location& loc, const std::string& msg, const std::string& help)
+        : location(loc), message(msg), help_text(help) {}
+
+    Location location;
+    Label toolchain_label;
+
+    std::vector<LocationRange> ranges;
+
+    std::string message;
+    std::string help_text;
+
+    std::vector<Err> sub_errs;
+  };
+
  public:
   using RangeList = std::vector<LocationRange>;
 
   // Indicates no error.
-  Err();
+  Err() = default;
 
   // Error at a single point.
   Err(const Location& location,
@@ -52,25 +68,27 @@
 
   // Error at a given value.
   Err(const Value& value,
-      const std::string msg,
+      const std::string& msg,
       const std::string& help_text = std::string());
 
   Err(const Err& other);
+  Err(Err&& other) = default;
 
-  ~Err();
+  Err& operator=(const Err&);
+  Err& operator=(Err&&) = default;
 
-  Err& operator=(const Err&) = default;
+  bool has_error() const { return !!info_; }
 
-  bool has_error() const { return has_error_; }
-  const Location& location() const { return location_; }
-  const std::string& message() const { return message_; }
-  const std::string& help_text() const { return help_text_; }
+  // All getters and setters below require has_error() returns true.
+  const Location& location() const { return info_->location; }
+  const std::string& message() const { return info_->message; }
+  const std::string& help_text() const { return info_->help_text; }
 
-  void AppendRange(const LocationRange& range) { ranges_.push_back(range); }
-  const RangeList& ranges() const { return ranges_; }
+  void AppendRange(const LocationRange& range) { info_->ranges.push_back(range); }
+  const RangeList& ranges() const { return info_->ranges; }
 
   void set_toolchain_label(const Label& toolchain_label) {
-    toolchain_label_ = toolchain_label;
+    info_->toolchain_label = toolchain_label;
   }
 
   void AppendSubErr(const Err& err);
@@ -92,16 +110,7 @@
  private:
   void InternalPrintToStdout(bool is_sub_err, bool is_fatal) const;
 
-  bool has_error_;
-  Location location_;
-  Label toolchain_label_;
-
-  std::vector<LocationRange> ranges_;
-
-  std::string message_;
-  std::string help_text_;
-
-  std::vector<Err> sub_errs_;
+  std::unique_ptr<ErrInfo> info_;  // Non-null indicates error.
 };
 
 #endif  // TOOLS_GN_ERR_H_
diff --git a/src/gn/setup_unittest.cc b/src/gn/setup_unittest.cc
index af10a6e..370f722 100644
--- a/src/gn/setup_unittest.cc
+++ b/src/gn/setup_unittest.cc
@@ -75,7 +75,6 @@
             setup.DoSetupWithErr(FilePathToUTF8(build_temp_dir.GetPath()), true,
                                  cmdline, &err));
   EXPECT_EQ(success, !err.has_error());
-  EXPECT_EQ(expected_error_message, err.message());
 }
 
 TEST_F(SetupTest, NoSeparatorInExtension) {