Remove Expect from core library.

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.
 
 library status_expression;
 
 /**
  * Parse and evaluate expressions in a .status file for Dart and V8.
  * There are set expressions and Boolean expressions in a .status file.
  * The grammar is:
@@ skipping 211 matching lines @@
       left = new SetUnion(left, right);
     }
     return left;
   }
 
 
   SetExpression parseSetAtomic() {
     if (scanner.current == Token.LEFT_PAREN) {
       scanner.advance();
       SetExpression value = parseSetExpression();
-      Expect.equals(scanner.current, Token.RIGHT_PAREN,
-                    "Missing right parenthesis in expression");
+      if (scanner.current != Token.RIGHT_PAREN) {
+        throw new RuntimeError("Missing right parenthesis in expression");
+      }
       scanner.advance();
       return value;
     }
-    Expect.isTrue(new RegExp(r"^\w+$").hasMatch(scanner.current),
-                  "Expected identifier in expression, got ${scanner.current}");
+    if (!new RegExp(r"^\w+$").hasMatch(scanner.current)) {
+      throw new RuntimeError(
+          "Expected identifier in expression, got ${scanner.current}");
+    }
     SetExpression value = new SetConstant(scanner.current);
     scanner.advance();
     return value;
   }
 
   BooleanExpression parseBooleanExpression() => parseBooleanOr();
 
   BooleanExpression parseBooleanOr() {
     BooleanExpression left = parseBooleanAnd();
     while (scanner.hasMore() && scanner.current == Token.OR) {
@@ skipping 11 matching lines @@
       BooleanExpression right = parseBooleanAtomic();
       left = new BooleanOperation(Token.AND, left, right);
     }
     return left;
   }
 
   BooleanExpression parseBooleanAtomic() {
     if (scanner.current == Token.LEFT_PAREN) {
       scanner.advance();
       BooleanExpression value = parseBooleanExpression();
-      Expect.equals(scanner.current, Token.RIGHT_PAREN,
-                    "Missing right parenthesis in expression");
+      if (scanner.current != Token.RIGHT_PAREN) {
+        throw new RuntimeError("Missing right parenthesis in expression");
+      }
       scanner.advance();
       return value;
     }
 
     // The only atomic booleans are of the form $variable == value or the
     // form $variable.
-    Expect.equals(scanner.current, Token.DOLLAR_SYMBOL,
-        "Expected \$ in expression, got ${scanner.current}");
+    if (scanner.current != Token.DOLLAR_SYMBOL) {
+      throw new RuntimeError(
+          "Expected \$ in expression, got ${scanner.current}");
+    }
     scanner.advance();
-    Expect.isTrue(new RegExp(r"^\w+$").hasMatch(scanner.current),
-        "Expected identifier in expression, got ${scanner.current}");
+    if (!new RegExp(r"^\w+$").hasMatch(scanner.current)) {
+      throw new RuntimeError(
+          "Expected identifier in expression, got ${scanner.current}");
+    }
     TermVariable left = new TermVariable(scanner.current);
     scanner.advance();
     if (scanner.current == Token.EQUALS) {
       scanner.advance();
-      Expect.isTrue(new RegExp(r"^\w+$").hasMatch(scanner.current),
-          "Expected identifier in expression, got ${scanner.current}");
+      if (!new RegExp(r"^\w+$").hasMatch(scanner.current)) {
+        throw new RuntimeError(
+            "Expected identifier in expression, got ${scanner.current}");
+      }
       TermConstant right = new TermConstant(scanner.current);
       scanner.advance();
       return new Comparison(left, right);
     } else {
       return new BooleanVariable(left);
     }
   }
 }