Define equality for boolean selectors.

lib/src/ast.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:source_span/source_span.dart';
 
 import 'visitor.dart';
 
 /// The superclass of nodes in the boolean selector abstract syntax tree.
 abstract class Node {
@@ skipping 20 matching lines @@
   /// The variable name.
   final String name;
 
   Iterable<String> get variables => [name];
 
   VariableNode(this.name, [this.span]);
 
   accept(Visitor visitor) => visitor.visitVariable(this);
 
   String toString() => name;
+
+  bool operator==(other) => other is VariableNode && name == other.name;
+
+  int get hashCode => name.hashCode;
 }
 
 /// A negation expression.
 class NotNode implements Node {
   final FileSpan span;
 
   /// The expression being negated.
   final Node child;
 
   Iterable<String> get variables => child.variables;
 
   NotNode(this.child, [this.span]);
 
   accept(Visitor visitor) => visitor.visitNot(this);
 
   String toString() => child is VariableNode || child is NotNode
       ? "!$child"
       : "!($child)";
+
+  bool operator==(other) => other is NotNode && child == other.child;
+
+  int get hashCode => ~child.hashCode;
 }
 
 /// An or expression.
 class OrNode implements Node {
   FileSpan get span => _expandSafe(left.span, right.span);
 
   /// The left-hand branch of the expression.
   final Node left;
 
   /// The right-hand branch of the expression.
@@ skipping 11 matching lines @@
   String toString() {
     var string1 = left is AndNode || left is ConditionalNode
         ? "($left)"
         : left;
     var string2 = right is AndNode || right is ConditionalNode
         ? "($right)"
         : right;
 
     return "$string1 || $string2";
   }
+
+  bool operator==(other) =>
+      other is OrNode && left == other.left && right == other.right;
+
+  int get hashCode => left.hashCode ^ right.hashCode;
 }
 
 /// An and expression.
 class AndNode implements Node {
   FileSpan get span => _expandSafe(left.span, right.span);
 
   /// The left-hand branch of the expression.
   final Node left;
 
   /// The right-hand branch of the expression.
@@ skipping 11 matching lines @@
   String toString() {
     var string1 = left is OrNode || left is ConditionalNode
         ? "($left)"
         : left;
     var string2 = right is OrNode || right is ConditionalNode
         ? "($right)"
         : right;
 
     return "$string1 && $string2";
   }
+
+  bool operator==(other) =>
+      other is AndNode && left == other.left && right == other.right;
+
+  int get hashCode => left.hashCode ^ right.hashCode;
 }
 
 /// A ternary conditional expression.
 class ConditionalNode implements Node {
   FileSpan get span => _expandSafe(condition.span, whenFalse.span);
 
   /// The condition expression to check.
   final Node condition;
 
   /// The branch to run if the condition is true.
@@ skipping 11 matching lines @@
   ConditionalNode(this.condition, this.whenTrue, this.whenFalse);
 
   accept(Visitor visitor) => visitor.visitConditional(this);
 
   String toString() {
     var conditionString =
         condition is ConditionalNode ? "($condition)" : condition;
     var trueString = whenTrue is ConditionalNode ? "($whenTrue)" : whenTrue;
     return "$conditionString ? $trueString : $whenFalse";
   }
+
+  bool operator==(other) =>
+      other is ConditionalNode &&
+      condition == other.condition &&
+      whenTrue == other.whenTrue &&
+      whenFalse == other.whenFalse;
+
+  int get hashCode =>
+      condition.hashCode ^ whenTrue.hashCode ^ whenFalse.hashCode;
 }
 
 /// Like [FileSpan.expand], except if [start] and [end] are `null` or from
 /// different files it returns `null` rather than throwing an error.
 FileSpan _expandSafe(FileSpan start, FileSpan end) {
   if (start == null || end == null) return null;
   if (start.file != end.file) return null;
   return start.expand(end);
 }