A minimal status file formatter and canonicalizer.

pkg/status_file/lib/src/expression.dart

 // Copyright (c) 2017, 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 '../environment.dart';
 
 /// A parsed Boolean expression AST.
 abstract class Expression {
   /// Parses Boolean expressions in a .status file for Dart.
   ///
@@ skipping 73 matching lines @@
   _ComparisonExpression(this.left, this.right, this.negate);
 
   void validate(Environment environment, List<String> errors) {
     environment.validate(left.name, right, errors);
   }
 
   bool evaluate(Environment environment) {
     return negate != (left.lookup(environment) == right);
   }
 
-  String toString() => "(\$${left.name} ${negate ? '!=' : '=='} $right)";
+  String toString() => "\$${left.name} ${negate ? '!=' : '=='} $right";
 }
 
 /// A reference to a variable defined in the environment. The expression
 /// evaluates to true if the variable's stringified value is "true".
 /// ```
 ///     $variable
 /// ```
 /// is equivalent to
 /// ```
 ///     $variable == true
@@ skipping 13 matching lines @@
   _VariableExpression(this.variable, {this.negate = false});
 
   void validate(Environment environment, List<String> errors) {
     // It must be a Boolean, so it should allow either Boolean value.
     environment.validate(variable.name, "true", errors);
   }
 
   bool evaluate(Environment environment) =>
       negate != (variable.lookup(environment) == "true");
 
-  String toString() => "(bool ${negate ? "! " : ""}\$${variable.name})";
+  String toString() => "${negate ? "!" : ""}\$${variable.name}";
 }
 
 /// A logical `||` or `&&` expression.
 class _LogicExpression implements Expression {
   /// The operator, `||` or `&&`.
   final String op;
 
   final Expression left;
   final Expression right;
 
   _LogicExpression(this.op, this.left, this.right);
 
   void validate(Environment environment, List<String> errors) {
     left.validate(environment, errors);
     right.validate(environment, errors);
   }
 
   bool evaluate(Environment environment) => (op == _Token.and)
       ? left.evaluate(environment) && right.evaluate(environment)
       : left.evaluate(environment) || right.evaluate(environment);
 
-  String toString() => "($left $op $right)";
+  String toString() {
+    String parenthesize(Expression operand) {
+      var result = operand.toString();
+      if (op == "&&" && operand is _LogicExpression && operand.op == "||") {
+        result = "($result)";
+      }
+
+      return result;
+    }
+
+    return "${parenthesize(left)} $op ${parenthesize(right)}";
+  }
 }
 
 /// Parser for Boolean expressions in a .status file for Dart.
 class _ExpressionParser {
   final _Scanner _scanner;
 
   _ExpressionParser(String expression) : _scanner = new _Scanner(expression);
 
   Expression parse() {
     var expression = _parseOr();
@@ skipping 122 matching lines @@
     return true;
   }
 
   /// Consumes the current token and returns it.
   String advance() {
     var previous = current;
     current = tokenIterator.moveNext() ? tokenIterator.current : null;
     return previous;
   }
 }