diff --git a/tools/gn/parser.cc b/tools/gn/parser.cc
index df57c9e..f4f028f 100644
--- a/tools/gn/parser.cc
+++ b/tools/gn/parser.cc
@@ -214,6 +214,11 @@
 
     myvalues.foo += 2
     empty_scope.new_thing = [ 1, 2, 3 ]
+
+  Scope equality is defined as single-level scopes identical within the current
+  scope. That is, all values in the first scope must be present and identical
+  within the second, and vice versa. Note that this means inherited scopes are
+  always unequal by definition.
 )*";
 
 enum Precedence {
diff --git a/tools/gn/scope.cc b/tools/gn/scope.cc
index 2368356..dd1a576 100644
--- a/tools/gn/scope.cc
+++ b/tools/gn/scope.cc
@@ -274,6 +274,23 @@
     (*output)[pair.first] = pair.second.value;
 }
 
+bool Scope::CheckCurrentScopeValuesEqual(const Scope* other) const {
+  // If there are containing scopes, equality shouldn't work.
+  if (containing()) {
+    return false;
+  }
+  if (values_.size() != other->values_.size()) {
+    return false;
+  }
+  for (const auto& pair : values_) {
+    const Value* v = other->GetValue(pair.first);
+    if (!v || *v != pair.second.value) {
+      return false;
+    }
+  }
+  return true;
+}
+
 bool Scope::NonRecursiveMergeTo(Scope* dest,
                                 const MergeOptions& options,
                                 const ParseNode* node_for_err,
diff --git a/tools/gn/scope.h b/tools/gn/scope.h
index 5e9745a..585f151 100644
--- a/tools/gn/scope.h
+++ b/tools/gn/scope.h
@@ -220,6 +220,11 @@
   // scopes.
   void GetCurrentScopeValues(KeyValueMap* output) const;
 
+  // Returns true if the values in the current scope are the same as all
+  // values in the given scope, without going to the parent scopes. Returns
+  // false if not.
+  bool CheckCurrentScopeValuesEqual(const Scope* other) const;
+
   // Copies this scope's values into the destination. Values from the
   // containing scope(s) (normally shadowed into the current one) will not be
   // copied, neither will the reference to the containing scope (this is why
diff --git a/tools/gn/value.cc b/tools/gn/value.cc
index 04db7ee..aff4ab1 100644
--- a/tools/gn/value.cc
+++ b/tools/gn/value.cc
@@ -196,10 +196,7 @@
       }
       return true;
     case Value::SCOPE:
-      // Scopes are always considered not equal because there's currently
-      // no use case for comparing them, and it requires a bunch of complex
-      // iteration code.
-      return false;
+      return scope_value()->CheckCurrentScopeValuesEqual(other.scope_value());
     default:
       return false;
   }
diff --git a/tools/gn/value.h b/tools/gn/value.h
index 13beb6f..912717d 100644
--- a/tools/gn/value.h
+++ b/tools/gn/value.h
@@ -113,7 +113,9 @@
   // false and sets the error.
   bool VerifyTypeIs(Type t, Err* err) const;
 
-  // Compares values. Only the "value" is compared, not the origin.
+  // Compares values. Only the "value" is compared, not the origin. Scope
+  // values check only the contents of the current scope, and do not go to
+  // parent scopes.
   bool operator==(const Value& other) const;
   bool operator!=(const Value& other) const;
 
diff --git a/tools/gn/value_unittest.cc b/tools/gn/value_unittest.cc
index 40ddf38..dd9be95 100644
--- a/tools/gn/value_unittest.cc
+++ b/tools/gn/value_unittest.cc
@@ -33,11 +33,28 @@
 
   // Scopes.
   TestWithScope setup;
-  Scope* scope = new Scope(setup.scope());
+  Scope* scope = new Scope(setup.settings());
   Value scopeval(nullptr, std::unique_ptr<Scope>(scope));
   EXPECT_EQ("{ }", scopeval.ToString(false));
 
+  // Test that an empty scope equals an empty scope.
+  EXPECT_TRUE(scopeval == scopeval);
+
   scope->SetValue("a", Value(nullptr, static_cast<int64_t>(42)), nullptr);
   scope->SetValue("b", Value(nullptr, "hello, world"), nullptr);
   EXPECT_EQ("{\n  a = 42\n  b = \"hello, world\"\n}", scopeval.ToString(false));
+  EXPECT_TRUE(scopeval == scopeval);
+
+  Scope* inner_scope = new Scope(setup.settings());
+  Value inner_scopeval(nullptr, std::unique_ptr<Scope>(inner_scope));
+  inner_scope->SetValue("d", Value(nullptr, static_cast<int64_t>(42)), nullptr);
+  scope->SetValue("c", inner_scopeval, nullptr);
+
+  // Test inner scope equality.
+  EXPECT_TRUE(scopeval == scopeval);
+
+  // Nested scopes should not be equal.
+  Scope* nested_scope = new Scope(scope);
+  Value nested_scopeval(nullptr, std::unique_ptr<Scope>(nested_scope));
+  EXPECT_FALSE(nested_scopeval == nested_scopeval);
 }