Replace the configuration map with a typed object.

tools/testing/dart/status_expression.dart

 // Copyright (c) 2011, 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.
   ///
   /// The grammar is:
   ///
   ///     expression := or
   ///     or         := and ( "||" and )*
   ///     and        := primary ( "&&" primary )*
   ///     primary    := "$" 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);
+
   /// Evaluates the expression where all variables are defined by the given
   /// [environment].
-  bool evaluate(Map<String, dynamic> environment);
+  bool evaluate(Environment environment);
 }
 
 /// Keyword token strings.
 class _Token {
   static const leftParen = "(";
   static const rightParen = ")";
   static const dollar = r"$";
   static const equals = "==";
   static const notEqual = "!=";
   static const and = "&&";
   static const or = "||";
 }
 
 /// A reference to a variable.
 class _Variable {
   final String name;
 
   _Variable(this.name);
 
-  String lookup(Map<String, dynamic> environment) {
-    var value = environment[name];
+  String lookup(Environment environment) {
+    var value = environment.lookUp(name);
     if (value == null) {
       throw new Exception("Could not find '$name' in environment "
           "while evaluating status file expression.");
     }
 
     // Explicitly stringify all values so that things like:
     //
     //     $strong == true
     //
     // work correctly even though "true" is treated as a string here.
     // TODO(rnystrom): Is there a cleaner/safer way to do this?
     return value.toString();
   }
 }
 
 /// Tests whether a given variable is or is not equal some literal value, as in:
 ///
 ///     $variable == someValue
 class _ComparisonExpression implements Expression {
   final _Variable left;
   final String right;
   final bool negate;
 
   _ComparisonExpression(this.left, this.right, this.negate);
 
-  bool evaluate(Map<String, dynamic> environment) {
+  void validate(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
 /// evaluates to true if the variable's stringified value is "true".
 ///
 ///     $variable
 class _VariableExpression implements Expression {
   final _Variable variable;
 
   _VariableExpression(this.variable);
 
-  bool evaluate(Map<String, dynamic> environment) =>
+  void validate(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) =>
       variable.lookup(environment) == "true";
 
   String toString() => "(bool \$${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);
 
-  bool evaluate(Map<String, dynamic> environment) => (op == _Token.and)
+  void validate(List<String> errors) {
+    left.validate(errors);
+    right.validate(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.
 class _ExpressionParser {
   final _Scanner _scanner;
 
@@ skipping 115 matching lines @@
     return true;
   }
 
   /// Consumes the current token and returns it.
   String advance() {
     var previous = current;
     current = tokenIterator.moveNext() ? tokenIterator.current : null;
     return previous;
   }
 }