Move the status file parser into its own package.

pkg/status_file/lib/src/expression.dart

-// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+// 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';
+import '../environment.dart';
 
 /// A parsed Boolean expression AST.
 abstract class Expression {
   /// Parses Boolean expressions in a .status file for Dart.
   ///
   /// The grammar is:
   ///
   ///     expression := or
   ///     or         := and ( "||" and )*
   ///     and        := primary ( "&&" primary )*
   ///     primary    := "$" identifier ( "==" | "!=" ) identifier |
   ///                   "!"? "$" identifier |
   ///                   "(" expression ")"
   ///     identifier := regex "\w+"
   ///
   /// Expressions evaluate as expected, with values of variables found in an
   /// environment passed to the evaluator.
   static Expression parse(String expression) =>
       new _ExpressionParser(expression).parse();
 
   /// Validates that this expression does not contain any invalid uses of
   /// variables.
   ///
   /// Ensures that any variable names are known and that any literal values are
   /// allowed for their corresponding variable. If an invalid variable or value
   /// is found, adds appropriate error messages to [errors].
-  void validate(List<String> errors);
+  void validate(Environment environment, List<String> errors);
 
   /// Evaluates the expression where all variables are defined by the given
   /// [environment].
   bool evaluate(Environment environment);
 }
 
 /// Keyword token strings.
 class _Token {
   static const leftParen = "(";
   static const rightParen = ")";
@@ skipping 33 matching lines @@
 /// $variable == someValue
 /// ```
 /// Negate the result if [negate] is true.
 class _ComparisonExpression implements Expression {
   final _Variable left;
   final String right;
   final bool negate;
 
   _ComparisonExpression(this.left, this.right, this.negate);
 
-  void validate(List<String> errors) {
-    Environment.validate(left.name, right, errors);
+  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)";
 }
 
 /// A reference to a variable defined in the environment. The expression
@@ skipping 12 matching lines @@
 /// is equivalent to
 /// ```
 ///     $variable != true
 /// ```
 class _VariableExpression implements Expression {
   final _Variable variable;
   final bool negate;
 
   _VariableExpression(this.variable, {this.negate = false});
 
-  void validate(List<String> errors) {
+  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);
+    environment.validate(variable.name, "true", errors);
   }
 
   bool evaluate(Environment environment) =>
       negate != (variable.lookup(environment) == "true");
 
   String toString() => "(bool ${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(List<String> errors) {
-    left.validate(errors);
-    right.validate(errors);
+  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)";
 }
 
 /// Parser for Boolean expressions in a .status file for Dart.
@@ skipping 129 matching lines @@
     return true;
   }
 
   /// Consumes the current token and returns it.
   String advance() {
     var previous = current;
     current = tokenIterator.moveNext() ? tokenIterator.current : null;
     return previous;
   }
 }