Begin running tests in TopLevelParserTest using the Fasta parser.

pkg/analyzer/test/generated/parser_test.dart

 // Copyright (c) 2014, 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 analyzer.test.generated.parser_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
@@ skipping 20 matching lines @@
     defineReflectiveTests(RecoveryParserTest);
     defineReflectiveTests(SimpleParserTest);
     defineReflectiveTests(TopLevelParserTest);
   });
 }
 
 /**
  * Abstract base class for parser tests, which does not make assumptions about
  * which parser is used.
  */
-abstract class AbstractParserTestCase {
+abstract class AbstractParserTestCase implements ParserTestHelpers {
   void set enableGenericMethodComments(bool value);
 
   void set enableNnbd(bool value);
 
+  /**
+   * Set a flag indicating whether the parser is to parse part-of directives
+   * that specify a URI rather than a library name.
+   */
+  void set enableUriInPartOf(bool value);
+
+  /**
+   * Get the parser used by the test.
+   *
+   * Caller must first invoke [createParser].
+   */
+  Parser get parser;
+
+  /**
+   * Asserts that no errors occurred during parsing.
+   */
+  void assertNoErrors();
+
+  /**
+   * Prepares to parse using tokens scanned from the given [content] string.
+   */
+  void createParser(String content);
+
   CompilationUnit parseCompilationUnit(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]);
 
   /// TODO(paulberry): merge with [parseCompilationUnit]
   CompilationUnit parseCompilationUnitWithOptions(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]);
 
+  /**
+   * Parse the given source as a compilation unit.
+   *
+   * @param source the source to be parsed
+   * @param errorCodes the error codes of the errors that are expected to be found
+   * @return the compilation unit that was parsed
+   * @throws Exception if the source could not be parsed, if the compilation errors in the source do
+   *           not match those that are expected, or if the result would have been `null`
+   */
+  CompilationUnit parseDirectives(String source,
+      [List<ErrorCode> errorCodes = const <ErrorCode>[]]);
+
   Expression parseExpression(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]);
 
+  /**
+   * Parses a single top level member of a compilation unit (other than a
+   * directive), including any comment and/or metadata that precedes it.
+   */
+  CompilationUnitMember parseFullCompilationUnitMember();
+
+  /**
+   * Parses a single top level directive, including any comment and/or metadata
+   * that precedes it.
+   */
+  Directive parseFullDirective();
+
   Statement parseStatement(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[],
       bool enableLazyAssignmentOperators]);
 }
 
 /**
  * Instances of the class `AstValidator` are used to validate the correct construction of an
  * AST structure.
  */
 class AstValidator extends UnifyingAstVisitor<Object> {
@@ skipping 2926 matching lines @@
    */
   GatheringErrorListener listener;
 
   /**
    * The parser used by the test.
    *
    * This field is typically initialized by invoking [createParser].
    */
   Parser parser;
 
+  @override
+  void assertNoErrors() {
+    listener.assertNoErrors();
+  }
+
   /**
    * Create the [parser] and [listener] used by a test. The [parser] will be
    * prepared to parse the tokens scanned from the given [content].
    */
   void createParser(String content) {
     listener = new GatheringErrorListener();
     //
     // Scan the source.
     //
     TestSource source = new TestSource();
@@ skipping 65 matching lines @@
    */
   CompilationUnit parseCompilationUnitWithOptions(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
     createParser(source);
     CompilationUnit unit = parser.parseCompilationUnit2();
     expect(unit, isNotNull);
     listener.assertErrorsWithCodes(errorCodes);
     return unit;
   }
 
+  @override
+  CompilationUnit parseDirectives(String source,
+      [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
+    createParser(source);
+    CompilationUnit unit = parser.parseDirectives2();
+    expect(unit, isNotNull);
+    expect(unit.declarations, hasLength(0));
+    listener.assertErrorsWithCodes(errorCodes);
+    return unit;
+  }
+
   /**
    * Parse the given source as an expression.
    *
    * @param source the source to be parsed
    * @param errorCodes the error codes of the errors that are expected to be found
    * @return the expression that was parsed
    * @throws Exception if the source could not be parsed, if the compilation errors in the source do
    *           not match those that are expected, or if the result would have been `null`
    */
   Expression parseExpression(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
     createParser(source);
     Expression expression = parser.parseExpression2();
     expectNotNullIfNoErrors(expression);
     listener.assertErrorsWithCodes(errorCodes);
     return expression;
   }
 
   /**
    * Parses a single top level member of a compilation unit (other than a
    * directive), including any comment and/or metadata that precedes it.
    */
   CompilationUnitMember parseFullCompilationUnitMember() =>
       parser.parseCompilationUnitMember(parser.parseCommentAndMetadata());
 
-  /**
-   * Parses a single top level directive, including any comment and/or metadata
-   * that precedes it.
-   */
+  @override
   Directive parseFullDirective() =>
       parser.parseDirective(parser.parseCommentAndMetadata());
 
   /**
    * Parses a variable declaration list (equivalent to a variable declaration
    * statement, but without the final comma).
    */
   VariableDeclarationList parseFullVariableDeclarationList() =>
       parser.parseVariableDeclarationListAfterMetadata(
           parser.parseCommentAndMetadata());
@@ skipping 9761 matching lines @@
    * @throws Exception if the method could not be invoked or throws an exception
    */
   bool _isSwitchMember(String source) {
     createParser(source);
     bool result = parser.isSwitchMember();
     expectNotNullIfNoErrors(result);
     return result;
   }
 }
 
+@reflectiveTest
+class TopLevelParserTest extends ParserTestCase with TopLevelParserTestMixin {}
+
 /**
  * Tests which exercise the parser using a complete compilation unit or
  * compilation unit member.
  */
-@reflectiveTest
-class TopLevelParserTest extends ParserTestCase {
+abstract class TopLevelParserTestMixin implements AbstractParserTestCase {
   void test_function_literal_allowed_at_toplevel() {
     parseCompilationUnit("var x = () {};");
   }
 
   void
       test_function_literal_allowed_in_ArgumentList_in_ConstructorFieldInitializer() {
     parseCompilationUnit("class C { C() : a = f(() {}); }");
   }
 
   void
@@ skipping 26 matching lines @@
   }
 
   void test_import_show_hide() {
     parseCompilationUnit(
         "import 'import1_lib.dart' show hide, show hide ugly;");
   }
 
   void test_parseClassDeclaration_abstract() {
     createParser('abstract class A {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<ClassDeclaration>());
     ClassDeclaration declaration = member;
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNotNull);
     expect(declaration.extendsClause, isNull);
     expect(declaration.implementsClause, isNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
     expect(declaration.members, hasLength(0));
     expect(declaration.rightBracket, isNotNull);
     expect(declaration.typeParameters, isNull);
   }
 
   void test_parseClassDeclaration_empty() {
     createParser('class A {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<ClassDeclaration>());
     ClassDeclaration declaration = member;
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
     expect(declaration.extendsClause, isNull);
     expect(declaration.implementsClause, isNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
     expect(declaration.members, hasLength(0));
     expect(declaration.rightBracket, isNotNull);
     expect(declaration.typeParameters, isNull);
   }
 
   void test_parseClassDeclaration_extends() {
     createParser('class A extends B {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<ClassDeclaration>());
     ClassDeclaration declaration = member;
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
     expect(declaration.extendsClause, isNotNull);
     expect(declaration.implementsClause, isNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
     expect(declaration.members, hasLength(0));
     expect(declaration.rightBracket, isNotNull);
     expect(declaration.typeParameters, isNull);
   }
 
   void test_parseClassDeclaration_extendsAndImplements() {
     createParser('class A extends B implements C {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<ClassDeclaration>());
     ClassDeclaration declaration = member;
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
     expect(declaration.extendsClause, isNotNull);
     expect(declaration.implementsClause, isNotNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
     expect(declaration.members, hasLength(0));
     expect(declaration.rightBracket, isNotNull);
     expect(declaration.typeParameters, isNull);
   }
 
   void test_parseClassDeclaration_extendsAndWith() {
     createParser('class A extends B with C {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<ClassDeclaration>());
     ClassDeclaration declaration = member;
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.name, isNotNull);
     expect(declaration.typeParameters, isNull);
     expect(declaration.extendsClause, isNotNull);
     expect(declaration.withClause, isNotNull);
     expect(declaration.implementsClause, isNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.members, hasLength(0));
     expect(declaration.rightBracket, isNotNull);
   }
 
   void test_parseClassDeclaration_extendsAndWithAndImplements() {
     createParser('class A extends B with C implements D {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<ClassDeclaration>());
     ClassDeclaration declaration = member;
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.name, isNotNull);
     expect(declaration.typeParameters, isNull);
     expect(declaration.extendsClause, isNotNull);
     expect(declaration.withClause, isNotNull);
     expect(declaration.implementsClause, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.members, hasLength(0));
     expect(declaration.rightBracket, isNotNull);
   }
 
   void test_parseClassDeclaration_implements() {
     createParser('class A implements C {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<ClassDeclaration>());
     ClassDeclaration declaration = member;
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
     expect(declaration.extendsClause, isNull);
     expect(declaration.implementsClause, isNotNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
     expect(declaration.members, hasLength(0));
     expect(declaration.rightBracket, isNotNull);
     expect(declaration.typeParameters, isNull);
   }
 
   void test_parseClassDeclaration_native() {
     createParser('class A native "nativeValue" {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<ClassDeclaration>());
     ClassDeclaration declaration = member;
     NativeClause nativeClause = declaration.nativeClause;
     expect(nativeClause, isNotNull);
     expect(nativeClause.nativeKeyword, isNotNull);
     expect(nativeClause.name.stringValue, "nativeValue");
     expect(nativeClause.beginToken, same(nativeClause.nativeKeyword));
     expect(nativeClause.endToken, same(nativeClause.name.endToken));
   }
 
   void test_parseClassDeclaration_nonEmpty() {
     createParser('class A {var f;}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<ClassDeclaration>());
     ClassDeclaration declaration = member;
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
     expect(declaration.extendsClause, isNull);
     expect(declaration.implementsClause, isNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
     expect(declaration.members, hasLength(1));
     expect(declaration.rightBracket, isNotNull);
     expect(declaration.typeParameters, isNull);
   }
 
   void test_parseClassDeclaration_typeAlias_implementsC() {
     createParser('class A = Object with B implements C;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<ClassTypeAlias>());
     ClassTypeAlias typeAlias = member;
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.typeParameters, isNull);
     expect(typeAlias.withClause, isNotNull);
     expect(typeAlias.implementsClause, isNotNull);
     expect(typeAlias.implementsClause.implementsKeyword, isNotNull);
     expect(typeAlias.implementsClause.interfaces.length, 1);
     expect(typeAlias.semicolon, isNotNull);
   }
 
   void test_parseClassDeclaration_typeAlias_withB() {
     createParser('class A = Object with B;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<ClassTypeAlias>());
     ClassTypeAlias typeAlias = member;
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.typeParameters, isNull);
     expect(typeAlias.withClause, isNotNull);
     expect(typeAlias.withClause.withKeyword, isNotNull);
     expect(typeAlias.withClause.mixinTypes.length, 1);
     expect(typeAlias.implementsClause, isNull);
     expect(typeAlias.semicolon, isNotNull);
   }
 
   void test_parseClassDeclaration_typeParameters() {
     createParser('class A<B> {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<ClassDeclaration>());
     ClassDeclaration declaration = member;
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
     expect(declaration.extendsClause, isNull);
     expect(declaration.implementsClause, isNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
     expect(declaration.members, hasLength(0));
     expect(declaration.rightBracket, isNotNull);
     expect(declaration.typeParameters, isNotNull);
     expect(declaration.typeParameters.typeParameters, hasLength(1));
   }
 
   void test_parseCompilationUnit_abstractAsPrefix_parameterized() {
     createParser('abstract<dynamic> _abstract = new abstract.A();');
     CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    listener.assertNoErrors();
+    expect(unit, isNotNull);
+    assertNoErrors();
     expect(unit.scriptTag, isNull);
     expect(unit.directives, hasLength(0));
     expect(unit.declarations, hasLength(1));
   }
 
   void test_parseCompilationUnit_builtIn_asFunctionName() {
     parseCompilationUnit('abstract(x) => 0;');
     parseCompilationUnit('as(x) => 0;');
     parseCompilationUnit('dynamic(x) => 0;');
     parseCompilationUnit('export(x) => 0;');
     parseCompilationUnit('external(x) => 0;');
     parseCompilationUnit('factory(x) => 0;');
     parseCompilationUnit('get(x) => 0;');
     parseCompilationUnit('implements(x) => 0;');
     parseCompilationUnit('import(x) => 0;');
     parseCompilationUnit('library(x) => 0;');
     parseCompilationUnit('operator(x) => 0;');
     parseCompilationUnit('part(x) => 0;');
     parseCompilationUnit('set(x) => 0;');
     parseCompilationUnit('static(x) => 0;');
     parseCompilationUnit('typedef(x) => 0;');
   }
 
   void test_parseCompilationUnit_directives_multiple() {
     createParser("library l;\npart 'a.dart';");
     CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    listener.assertNoErrors();
+    expect(unit, isNotNull);
+    assertNoErrors();
     expect(unit.scriptTag, isNull);
     expect(unit.directives, hasLength(2));
     expect(unit.declarations, hasLength(0));
   }
 
   void test_parseCompilationUnit_directives_single() {
     createParser('library l;');
     CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    listener.assertNoErrors();
+    expect(unit, isNotNull);
+    assertNoErrors();
     expect(unit.scriptTag, isNull);
     expect(unit.directives, hasLength(1));
     expect(unit.declarations, hasLength(0));
   }
 
   void test_parseCompilationUnit_empty() {
     createParser('');
     CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    listener.assertNoErrors();
+    expect(unit, isNotNull);
+    assertNoErrors();
     expect(unit.scriptTag, isNull);
     expect(unit.directives, hasLength(0));
     expect(unit.declarations, hasLength(0));
   }
 
   void test_parseCompilationUnit_exportAsPrefix() {
     createParser('export.A _export = new export.A();');
     CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    listener.assertNoErrors();
+    expect(unit, isNotNull);
+    assertNoErrors();
     expect(unit.scriptTag, isNull);
     expect(unit.directives, hasLength(0));
     expect(unit.declarations, hasLength(1));
   }
 
   void test_parseCompilationUnit_exportAsPrefix_parameterized() {
     createParser('export<dynamic> _export = new export.A();');
     CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    listener.assertNoErrors();
+    expect(unit, isNotNull);
+    assertNoErrors();
     expect(unit.scriptTag, isNull);
     expect(unit.directives, hasLength(0));
     expect(unit.declarations, hasLength(1));
   }
 
   void test_parseCompilationUnit_operatorAsPrefix_parameterized() {
     createParser('operator<dynamic> _operator = new operator.A();');
     CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    listener.assertNoErrors();
+    expect(unit, isNotNull);
+    assertNoErrors();
     expect(unit.scriptTag, isNull);
     expect(unit.directives, hasLength(0));
     expect(unit.declarations, hasLength(1));
   }
 
   void test_parseCompilationUnit_script() {
     createParser('#! /bin/dart');
     CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    listener.assertNoErrors();
+    expect(unit, isNotNull);
+    assertNoErrors();
     expect(unit.scriptTag, isNotNull);
     expect(unit.directives, hasLength(0));
     expect(unit.declarations, hasLength(0));
   }
 
   void test_parseCompilationUnit_skipFunctionBody_withInterpolation() {
     ParserTestCase.parseFunctionBodies = false;
     createParser('f() { "\${n}"; }');
     CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    listener.assertNoErrors();
+    expect(unit, isNotNull);
+    assertNoErrors();
     expect(unit.scriptTag, isNull);
     expect(unit.declarations, hasLength(1));
   }
 
   void test_parseCompilationUnit_topLevelDeclaration() {
     createParser('class A {}');
     CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    listener.assertNoErrors();
+    expect(unit, isNotNull);
+    assertNoErrors();
     expect(unit.scriptTag, isNull);
     expect(unit.directives, hasLength(0));
     expect(unit.declarations, hasLength(1));
   }
 
   void test_parseCompilationUnit_typedefAsPrefix() {
     createParser('typedef.A _typedef = new typedef.A();');
     CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    listener.assertNoErrors();
+    expect(unit, isNotNull);
+    assertNoErrors();
     expect(unit.scriptTag, isNull);
     expect(unit.directives, hasLength(0));
     expect(unit.declarations, hasLength(1));
   }
 
   void test_parseCompilationUnitMember_abstractAsPrefix() {
     createParser('abstract.A _abstract = new abstract.A();');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<TopLevelVariableDeclaration>());
     TopLevelVariableDeclaration declaration = member;
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
   }
 
   void test_parseCompilationUnitMember_class() {
     createParser('class A {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<ClassDeclaration>());
     ClassDeclaration declaration = member;
     expect(declaration.name.name, "A");
     expect(declaration.members, hasLength(0));
   }
 
   void test_parseCompilationUnitMember_classTypeAlias() {
     createParser('abstract class A = B with C;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<ClassTypeAlias>());
     ClassTypeAlias declaration = member;
     expect(declaration.name.name, "A");
     expect(declaration.abstractKeyword, isNotNull);
   }
 
   void test_parseCompilationUnitMember_constVariable() {
     createParser('const int x = 0;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<TopLevelVariableDeclaration>());
     TopLevelVariableDeclaration declaration = member;
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
   }
 
   void test_parseCompilationUnitMember_finalVariable() {
     createParser('final x = 0;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<TopLevelVariableDeclaration>());
     TopLevelVariableDeclaration declaration = member;
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
   }
 
   void test_parseCompilationUnitMember_function_external_noType() {
     createParser('external f();');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.externalKeyword, isNotNull);
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNull);
   }
 
   void test_parseCompilationUnitMember_function_external_type() {
     createParser('external int f();');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.externalKeyword, isNotNull);
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNull);
   }
 
   void test_parseCompilationUnitMember_function_generic_noReturnType() {
     createParser('f<E>() {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.returnType, isNull);
     expect(declaration.functionExpression.typeParameters, isNotNull);
   }
 
   void
       test_parseCompilationUnitMember_function_generic_noReturnType_annotated() {
     createParser('f<@a E>() {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.returnType, isNull);
     expect(declaration.functionExpression.typeParameters, isNotNull);
   }
 
   void test_parseCompilationUnitMember_function_generic_returnType() {
     createParser('E f<E>() {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.returnType, isNotNull);
     expect(declaration.functionExpression.typeParameters, isNotNull);
   }
 
   void test_parseCompilationUnitMember_function_generic_void() {
     createParser('void f<T>(T t) {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNull);
   }
 
   void test_parseCompilationUnitMember_function_noType() {
     createParser('f() {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNull);
   }
 
   void test_parseCompilationUnitMember_function_type() {
     createParser('int f() {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNull);
   }
 
   void test_parseCompilationUnitMember_function_void() {
     createParser('void f() {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.returnType, isNotNull);
   }
 
   void test_parseCompilationUnitMember_getter_external_noType() {
     createParser('external get p;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.externalKeyword, isNotNull);
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNotNull);
   }
 
   void test_parseCompilationUnitMember_getter_external_type() {
     createParser('external int get p;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.externalKeyword, isNotNull);
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNotNull);
   }
 
   void test_parseCompilationUnitMember_getter_noType() {
     createParser('get p => 0;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNotNull);
   }
 
   void test_parseCompilationUnitMember_getter_type() {
     createParser('int get p => 0;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNotNull);
   }
 
   void test_parseCompilationUnitMember_setter_external_noType() {
     createParser('external set p(v);');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.externalKeyword, isNotNull);
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNotNull);
   }
 
   void test_parseCompilationUnitMember_setter_external_type() {
     createParser('external void set p(int v);');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.externalKeyword, isNotNull);
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNotNull);
   }
 
   void test_parseCompilationUnitMember_setter_noType() {
     createParser('set p(v) {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNotNull);
   }
 
   void test_parseCompilationUnitMember_setter_type() {
     createParser('void set p(int v) {}');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<FunctionDeclaration>());
     FunctionDeclaration declaration = member;
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNotNull);
     expect(declaration.returnType, isNotNull);
   }
 
   void test_parseCompilationUnitMember_typeAlias_abstract() {
     createParser('abstract class C = S with M;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<ClassTypeAlias>());
     ClassTypeAlias typeAlias = member;
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name.name, "C");
     expect(typeAlias.typeParameters, isNull);
     expect(typeAlias.equals, isNotNull);
     expect(typeAlias.abstractKeyword, isNotNull);
     expect(typeAlias.superclass.name.name, "S");
     expect(typeAlias.withClause, isNotNull);
     expect(typeAlias.implementsClause, isNull);
     expect(typeAlias.semicolon, isNotNull);
   }
 
   void test_parseCompilationUnitMember_typeAlias_generic() {
     createParser('class C<E> = S<E> with M<E> implements I<E>;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<ClassTypeAlias>());
     ClassTypeAlias typeAlias = member;
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name.name, "C");
     expect(typeAlias.typeParameters.typeParameters, hasLength(1));
     expect(typeAlias.equals, isNotNull);
     expect(typeAlias.abstractKeyword, isNull);
     expect(typeAlias.superclass.name.name, "S");
     expect(typeAlias.withClause, isNotNull);
     expect(typeAlias.implementsClause, isNotNull);
     expect(typeAlias.semicolon, isNotNull);
   }
 
   void test_parseCompilationUnitMember_typeAlias_implements() {
     createParser('class C = S with M implements I;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<ClassTypeAlias>());
     ClassTypeAlias typeAlias = member;
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name.name, "C");
     expect(typeAlias.typeParameters, isNull);
     expect(typeAlias.equals, isNotNull);
     expect(typeAlias.abstractKeyword, isNull);
     expect(typeAlias.superclass.name.name, "S");
     expect(typeAlias.withClause, isNotNull);
     expect(typeAlias.implementsClause, isNotNull);
     expect(typeAlias.semicolon, isNotNull);
   }
 
   void test_parseCompilationUnitMember_typeAlias_noImplements() {
     createParser('class C = S with M;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<ClassTypeAlias>());
     ClassTypeAlias typeAlias = member;
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name.name, "C");
     expect(typeAlias.typeParameters, isNull);
     expect(typeAlias.equals, isNotNull);
     expect(typeAlias.abstractKeyword, isNull);
     expect(typeAlias.superclass.name.name, "S");
     expect(typeAlias.withClause, isNotNull);
     expect(typeAlias.implementsClause, isNull);
     expect(typeAlias.semicolon, isNotNull);
   }
 
   void test_parseCompilationUnitMember_typedef() {
     createParser('typedef F();');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<FunctionTypeAlias>());
     FunctionTypeAlias typeAlias = member;
     expect(typeAlias.name.name, "F");
     expect(typeAlias.parameters.parameters, hasLength(0));
   }
 
   void test_parseCompilationUnitMember_variable() {
     createParser('var x = 0;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<TopLevelVariableDeclaration>());
     TopLevelVariableDeclaration declaration = member;
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
   }
 
   void test_parseCompilationUnitMember_variableGet() {
     createParser('String get = null;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<TopLevelVariableDeclaration>());
     TopLevelVariableDeclaration declaration = member;
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
   }
 
   void test_parseCompilationUnitMember_variableSet() {
     createParser('String set = null;');
     CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertNoErrors();
+    expect(member, isNotNull);
+    assertNoErrors();
     expect(member, new isInstanceOf<TopLevelVariableDeclaration>());
     TopLevelVariableDeclaration declaration = member;
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
   }
 
   void test_parseDirective_export() {
     createParser("export 'lib/lib.dart';");
     Directive directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive, new isInstanceOf<ExportDirective>());
     ExportDirective exportDirective = directive;
     expect(exportDirective.keyword, isNotNull);
     expect(exportDirective.uri, isNotNull);
     expect(exportDirective.combinators, hasLength(0));
     expect(exportDirective.semicolon, isNotNull);
   }
 
   void test_parseDirective_import() {
     createParser("import 'lib/lib.dart';");
     Directive directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive, new isInstanceOf<ImportDirective>());
     ImportDirective importDirective = directive;
     expect(importDirective.keyword, isNotNull);
     expect(importDirective.uri, isNotNull);
     expect(importDirective.asKeyword, isNull);
     expect(importDirective.prefix, isNull);
     expect(importDirective.combinators, hasLength(0));
     expect(importDirective.semicolon, isNotNull);
   }
 
   void test_parseDirective_library() {
     createParser("library l;");
     Directive directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive, new isInstanceOf<LibraryDirective>());
     LibraryDirective libraryDirective = directive;
     expect(libraryDirective.libraryKeyword, isNotNull);
     expect(libraryDirective.name, isNotNull);
     expect(libraryDirective.semicolon, isNotNull);
   }
 
   void test_parseDirective_part() {
     createParser("part 'lib/lib.dart';");
     Directive directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive, new isInstanceOf<PartDirective>());
     PartDirective partDirective = directive;
     expect(partDirective.partKeyword, isNotNull);
     expect(partDirective.uri, isNotNull);
     expect(partDirective.semicolon, isNotNull);
   }
 
   void test_parseDirective_partOf() {
     createParser("part of l;");
     Directive directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive, new isInstanceOf<PartOfDirective>());
     PartOfDirective partOfDirective = directive;
     expect(partOfDirective.partKeyword, isNotNull);
     expect(partOfDirective.ofKeyword, isNotNull);
     expect(partOfDirective.libraryName, isNotNull);
     expect(partOfDirective.semicolon, isNotNull);
   }
 
   void test_parseDirectives_complete() {
     CompilationUnit unit =
-        _parseDirectives("#! /bin/dart\nlibrary l;\nclass A {}");
+        parseDirectives("#! /bin/dart\nlibrary l;\nclass A {}");
     expect(unit.scriptTag, isNotNull);
     expect(unit.directives, hasLength(1));
   }
 
   void test_parseDirectives_empty() {
-    CompilationUnit unit = _parseDirectives("");
+    CompilationUnit unit = parseDirectives("");
     expect(unit.scriptTag, isNull);
     expect(unit.directives, hasLength(0));
   }
 
   void test_parseDirectives_mixed() {
     CompilationUnit unit =
-        _parseDirectives("library l; class A {} part 'foo.dart';");
+        parseDirectives("library l; class A {} part 'foo.dart';");
     expect(unit.scriptTag, isNull);
     expect(unit.directives, hasLength(1));
   }
 
   void test_parseDirectives_multiple() {
-    CompilationUnit unit = _parseDirectives("library l;\npart 'a.dart';");
+    CompilationUnit unit = parseDirectives("library l;\npart 'a.dart';");
     expect(unit.scriptTag, isNull);
     expect(unit.directives, hasLength(2));
   }
 
   void test_parseDirectives_script() {
-    CompilationUnit unit = _parseDirectives("#! /bin/dart");
+    CompilationUnit unit = parseDirectives("#! /bin/dart");
     expect(unit.scriptTag, isNotNull);
     expect(unit.directives, hasLength(0));
   }
 
   void test_parseDirectives_single() {
-    CompilationUnit unit = _parseDirectives("library l;");
+    CompilationUnit unit = parseDirectives("library l;");
     expect(unit.scriptTag, isNull);
     expect(unit.directives, hasLength(1));
   }
 
   void test_parseDirectives_topLevelDeclaration() {
-    CompilationUnit unit = _parseDirectives("class A {}");
+    CompilationUnit unit = parseDirectives("class A {}");
     expect(unit.scriptTag, isNull);
     expect(unit.directives, hasLength(0));
   }
 
   void test_parseEnumDeclaration_one() {
     createParser("enum E {ONE}");
     EnumDeclaration declaration = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(declaration);
-    listener.assertNoErrors();
+    expect(declaration, isNotNull);
+    assertNoErrors();
     expect(declaration.documentationComment, isNull);
     expect(declaration.enumKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
     expect(declaration.constants, hasLength(1));
     expect(declaration.rightBracket, isNotNull);
   }
 
   void test_parseEnumDeclaration_trailingComma() {
     createParser("enum E {ONE,}");
     EnumDeclaration declaration = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(declaration);
-    listener.assertNoErrors();
+    expect(declaration, isNotNull);
+    assertNoErrors();
     expect(declaration.documentationComment, isNull);
     expect(declaration.enumKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
     expect(declaration.constants, hasLength(1));
     expect(declaration.rightBracket, isNotNull);
   }
 
   void test_parseEnumDeclaration_two() {
     createParser("enum E {ONE, TWO}");
     EnumDeclaration declaration = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(declaration);
-    listener.assertNoErrors();
+    expect(declaration, isNotNull);
+    assertNoErrors();
     expect(declaration.documentationComment, isNull);
     expect(declaration.enumKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
     expect(declaration.constants, hasLength(2));
     expect(declaration.rightBracket, isNotNull);
   }
 
   void test_parseExportDirective_configuration_multiple() {
     createParser("export 'lib/lib.dart' if (a) 'b.dart' if (c) 'd.dart';");
     ExportDirective directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.configurations, hasLength(2));
     expectDottedName(directive.configurations[0].name, ['a']);
     expectDottedName(directive.configurations[1].name, ['c']);
     expect(directive.combinators, hasLength(0));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseExportDirective_configuration_single() {
     createParser("export 'lib/lib.dart' if (a.b == 'c.dart') '';");
     ExportDirective directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.configurations, hasLength(1));
     expectDottedName(directive.configurations[0].name, ['a', 'b']);
     expect(directive.combinators, hasLength(0));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseExportDirective_hide() {
     createParser("export 'lib/lib.dart' hide A, B;");
     ExportDirective directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.combinators, hasLength(1));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseExportDirective_hide_show() {
     createParser("export 'lib/lib.dart' hide A show B;");
     ExportDirective directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.combinators, hasLength(2));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseExportDirective_noCombinator() {
     createParser("export 'lib/lib.dart';");
     ExportDirective directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.combinators, hasLength(0));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseExportDirective_show() {
     createParser("export 'lib/lib.dart' show A, B;");
     ExportDirective directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.combinators, hasLength(1));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseExportDirective_show_hide() {
     createParser("export 'lib/lib.dart' show B hide A;");
     ExportDirective directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.combinators, hasLength(2));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseFunctionDeclaration_function() {
     createParser('/// Doc\nT f() {}');
     FunctionDeclaration declaration = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(declaration);
-    listener.assertNoErrors();
+    expect(declaration, isNotNull);
+    assertNoErrors();
     expectCommentText(declaration.documentationComment, '/// Doc');
     expect((declaration.returnType as TypeName).name.name, 'T');
     expect(declaration.name, isNotNull);
     FunctionExpression expression = declaration.functionExpression;
     expect(expression, isNotNull);
     expect(expression.body, isNotNull);
     expect(expression.typeParameters, isNull);
     expect(expression.parameters, isNotNull);
     expect(declaration.propertyKeyword, isNull);
   }
 
   void test_parseFunctionDeclaration_functionWithTypeParameters() {
     createParser('/// Doc\nT f<E>() {}');
     FunctionDeclaration declaration = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(declaration);
-    listener.assertNoErrors();
+    expect(declaration, isNotNull);
+    assertNoErrors();
     expectCommentText(declaration.documentationComment, '/// Doc');
     expect((declaration.returnType as TypeName).name.name, 'T');
     expect(declaration.name, isNotNull);
     FunctionExpression expression = declaration.functionExpression;
     expect(expression, isNotNull);
     expect(expression.body, isNotNull);
     expect(expression.typeParameters, isNotNull);
     expect(expression.parameters, isNotNull);
     expect(declaration.propertyKeyword, isNull);
   }
 
   void test_parseFunctionDeclaration_functionWithTypeParameters_comment() {
     enableGenericMethodComments = true;
     createParser('/// Doc\nT f/*<E>*/() {}');
     FunctionDeclaration declaration = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(declaration);
-    listener.assertNoErrors();
+    expect(declaration, isNotNull);
+    assertNoErrors();
     expectCommentText(declaration.documentationComment, '/// Doc');
     expect((declaration.returnType as TypeName).name.name, 'T');
     expect(declaration.name, isNotNull);
     FunctionExpression expression = declaration.functionExpression;
     expect(expression, isNotNull);
     expect(expression.body, isNotNull);
     expect(expression.typeParameters, isNotNull);
     expect(expression.parameters, isNotNull);
     expect(declaration.propertyKeyword, isNull);
   }
 
   void test_parseFunctionDeclaration_getter() {
     createParser('/// Doc\nT get p => 0;');
     FunctionDeclaration declaration = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(declaration);
-    listener.assertNoErrors();
+    expect(declaration, isNotNull);
+    assertNoErrors();
     expectCommentText(declaration.documentationComment, '/// Doc');
     expect((declaration.returnType as TypeName).name.name, 'T');
     expect(declaration.name, isNotNull);
     FunctionExpression expression = declaration.functionExpression;
     expect(expression, isNotNull);
     expect(expression.body, isNotNull);
     expect(expression.typeParameters, isNull);
     expect(expression.parameters, isNull);
     expect(declaration.propertyKeyword, isNotNull);
   }
 
   void test_parseFunctionDeclaration_setter() {
     createParser('/// Doc\nT set p(v) {}');
     FunctionDeclaration declaration = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(declaration);
-    listener.assertNoErrors();
+    expect(declaration, isNotNull);
+    assertNoErrors();
     expectCommentText(declaration.documentationComment, '/// Doc');
     expect((declaration.returnType as TypeName).name.name, 'T');
     expect(declaration.name, isNotNull);
     FunctionExpression expression = declaration.functionExpression;
     expect(expression, isNotNull);
     expect(expression.body, isNotNull);
     expect(expression.typeParameters, isNull);
     expect(expression.parameters, isNotNull);
     expect(declaration.propertyKeyword, isNotNull);
   }
 
   @failingTest
   void test_parseGenericTypeAlias_noTypeParameters() {
     createParser('F = int Function(int);');
     GenericTypeAlias alias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(alias);
-    listener.assertNoErrors();
+    expect(alias, isNotNull);
+    assertNoErrors();
     expect(alias.name, isNotNull);
     expect(alias.name.name, 'F');
     expect(alias.typeParameters, isNull);
     expect(alias.equals, isNotNull);
     expect(alias.functionType, isNotNull);
     expect(alias.semicolon, isNotNull);
   }
 
   @failingTest
   void test_parseGenericTypeAlias_typeParameters() {
     createParser('F<T> = T Function(T);');
     GenericTypeAlias alias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(alias);
-    listener.assertNoErrors();
+    expect(alias, isNotNull);
+    assertNoErrors();
     expect(alias.name, isNotNull);
     expect(alias.name.name, 'F');
     expect(alias.typeParameters, isNotNull);
     expect(alias.equals, isNotNull);
     expect(alias.functionType, isNotNull);
     expect(alias.semicolon, isNotNull);
   }
 
   void test_parseImportDirective_configuration_multiple() {
     createParser("import 'lib/lib.dart' if (a) 'b.dart' if (c) 'd.dart';");
     ImportDirective directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.configurations, hasLength(2));
     expectDottedName(directive.configurations[0].name, ['a']);
     expectDottedName(directive.configurations[1].name, ['c']);
     expect(directive.deferredKeyword, isNull);
     expect(directive.asKeyword, isNull);
     expect(directive.prefix, isNull);
     expect(directive.combinators, hasLength(0));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseImportDirective_configuration_single() {
     createParser("import 'lib/lib.dart' if (a.b == 'c.dart') '';");
     ImportDirective directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.configurations, hasLength(1));
     expectDottedName(directive.configurations[0].name, ['a', 'b']);
     expect(directive.deferredKeyword, isNull);
     expect(directive.asKeyword, isNull);
     expect(directive.prefix, isNull);
     expect(directive.combinators, hasLength(0));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseImportDirective_deferred() {
     createParser("import 'lib/lib.dart' deferred as a;");
     ImportDirective directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.deferredKeyword, isNotNull);
     expect(directive.asKeyword, isNotNull);
     expect(directive.prefix, isNotNull);
     expect(directive.combinators, hasLength(0));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseImportDirective_hide() {
     createParser("import 'lib/lib.dart' hide A, B;");
     ImportDirective directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.deferredKeyword, isNull);
     expect(directive.asKeyword, isNull);
     expect(directive.prefix, isNull);
     expect(directive.combinators, hasLength(1));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseImportDirective_noCombinator() {
     createParser("import 'lib/lib.dart';");
     ImportDirective directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.deferredKeyword, isNull);
     expect(directive.asKeyword, isNull);
     expect(directive.prefix, isNull);
     expect(directive.combinators, hasLength(0));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseImportDirective_prefix() {
     createParser("import 'lib/lib.dart' as a;");
     ImportDirective directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.deferredKeyword, isNull);
     expect(directive.asKeyword, isNotNull);
     expect(directive.prefix, isNotNull);
     expect(directive.combinators, hasLength(0));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseImportDirective_prefix_hide_show() {
     createParser("import 'lib/lib.dart' as a hide A show B;");
     ImportDirective directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.deferredKeyword, isNull);
     expect(directive.asKeyword, isNotNull);
     expect(directive.prefix, isNotNull);
     expect(directive.combinators, hasLength(2));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseImportDirective_prefix_show_hide() {
     createParser("import 'lib/lib.dart' as a show B hide A;");
     ImportDirective directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.deferredKeyword, isNull);
     expect(directive.asKeyword, isNotNull);
     expect(directive.prefix, isNotNull);
     expect(directive.combinators, hasLength(2));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseImportDirective_show() {
     createParser("import 'lib/lib.dart' show A, B;");
     ImportDirective directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.deferredKeyword, isNull);
     expect(directive.asKeyword, isNull);
     expect(directive.prefix, isNull);
     expect(directive.combinators, hasLength(1));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseLibraryDirective() {
     createParser('library l;');
     LibraryDirective directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive.libraryKeyword, isNotNull);
     expect(directive.name, isNotNull);
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parsePartDirective() {
     createParser("part 'lib/lib.dart';");
     PartDirective directive = parseFullDirective();
-    expectNotNullIfNoErrors(directive);
-    listener.assertNoErrors();
+    expect(directive, isNotNull);
+    assertNoErrors();
     expect(directive.partKeyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parsePartOfDirective_name() {
     enableUriInPartOf = true;
     createParser("part of l;");
     PartOfDirective directive = parseFullDirective();
     expect(directive.partKeyword, isNotNull);
@@ skipping 10 matching lines @@
     expect(directive.partKeyword, isNotNull);
     expect(directive.ofKeyword, isNotNull);
     expect(directive.libraryName, isNull);
     expect(directive.uri, isNotNull);
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseTypeAlias_function_noParameters() {
     createParser('typedef bool F();');
     FunctionTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(typeAlias);
-    listener.assertNoErrors();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.parameters, isNotNull);
     expect(typeAlias.returnType, isNotNull);
     expect(typeAlias.semicolon, isNotNull);
     expect(typeAlias.typeParameters, isNull);
   }
 
   void test_parseTypeAlias_function_noReturnType() {
     createParser('typedef F();');
     FunctionTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(typeAlias);
-    listener.assertNoErrors();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.parameters, isNotNull);
     expect(typeAlias.returnType, isNull);
     expect(typeAlias.semicolon, isNotNull);
     expect(typeAlias.typeParameters, isNull);
   }
 
   void test_parseTypeAlias_function_parameterizedReturnType() {
     createParser('typedef A<B> F();');
     FunctionTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(typeAlias);
-    listener.assertNoErrors();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.parameters, isNotNull);
     expect(typeAlias.returnType, isNotNull);
     expect(typeAlias.semicolon, isNotNull);
     expect(typeAlias.typeParameters, isNull);
   }
 
   void test_parseTypeAlias_function_parameters() {
     createParser('typedef bool F(Object value);');
     FunctionTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(typeAlias);
-    listener.assertNoErrors();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.parameters, isNotNull);
     expect(typeAlias.returnType, isNotNull);
     expect(typeAlias.semicolon, isNotNull);
     expect(typeAlias.typeParameters, isNull);
   }
 
   void test_parseTypeAlias_function_typeParameters() {
     createParser('typedef bool F<E>();');
     FunctionTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(typeAlias);
-    listener.assertNoErrors();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.parameters, isNotNull);
     expect(typeAlias.returnType, isNotNull);
     expect(typeAlias.semicolon, isNotNull);
     expect(typeAlias.typeParameters, isNotNull);
   }
 
   void test_parseTypeAlias_function_voidReturnType() {
     createParser('typedef void F();');
     FunctionTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(typeAlias);
-    listener.assertNoErrors();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.parameters, isNotNull);
     expect(typeAlias.returnType, isNotNull);
     expect(typeAlias.semicolon, isNotNull);
     expect(typeAlias.typeParameters, isNull);
   }
 
   @failingTest
   void test_parseTypeAlias_genericFunction_noParameters() {
     createParser('typedef F = bool Function();');
     GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(typeAlias);
-    listener.assertNoErrors();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.typeParameters, isNull);
     expect(typeAlias.semicolon, isNotNull);
     GenericFunctionType functionType = typeAlias.functionType;
     expect(functionType, isNotNull);
     expect(functionType.parameters, isNotNull);
     expect(functionType.returnType, isNotNull);
     expect(functionType.typeParameters, isNull);
   }
 
   @failingTest
   void test_parseTypeAlias_genericFunction_noReturnType() {
     createParser('typedef F = Function();');
     GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(typeAlias);
-    listener.assertNoErrors();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.typeParameters, isNull);
     expect(typeAlias.semicolon, isNotNull);
     GenericFunctionType functionType = typeAlias.functionType;
     expect(functionType, isNotNull);
     expect(functionType.parameters, isNotNull);
     expect(functionType.returnType, isNull);
     expect(functionType.typeParameters, isNull);
   }
 
   @failingTest
   void test_parseTypeAlias_genericFunction_parameterizedReturnType() {
     createParser('typedef F = A<B> Function();');
     GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(typeAlias);
-    listener.assertNoErrors();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.typeParameters, isNull);
     expect(typeAlias.semicolon, isNotNull);
     GenericFunctionType functionType = typeAlias.functionType;
     expect(functionType, isNotNull);
     expect(functionType.parameters, isNotNull);
     expect(functionType.returnType, isNotNull);
     expect(functionType.typeParameters, isNull);
   }
 
   @failingTest
   void test_parseTypeAlias_genericFunction_parameters() {
     createParser('typedef F = bool Function(Object value);');
     GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(typeAlias);
-    listener.assertNoErrors();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.typeParameters, isNull);
     expect(typeAlias.semicolon, isNotNull);
     GenericFunctionType functionType = typeAlias.functionType;
     expect(functionType, isNotNull);
     expect(functionType.parameters, isNotNull);
     expect(functionType.returnType, isNotNull);
     expect(functionType.typeParameters, isNull);
   }
 
   @failingTest
   void test_parseTypeAlias_genericFunction_typeParameters() {
     createParser('typedef F = bool Function<E>();');
     GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(typeAlias);
-    listener.assertNoErrors();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.typeParameters, isNull);
     expect(typeAlias.semicolon, isNotNull);
     GenericFunctionType functionType = typeAlias.functionType;
     expect(functionType, isNotNull);
     expect(functionType.parameters, isNotNull);
     expect(functionType.returnType, isNotNull);
     expect(functionType.typeParameters, isNotNull);
   }
 
   @failingTest
   void test_parseTypeAlias_genericFunction_typeParameters_noParameters() {
     createParser('typedef F<T> = bool Function();');
     GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(typeAlias);
-    listener.assertNoErrors();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.typeParameters, isNotNull);
     expect(typeAlias.semicolon, isNotNull);
     GenericFunctionType functionType = typeAlias.functionType;
     expect(functionType, isNotNull);
     expect(functionType.parameters, isNotNull);
     expect(functionType.returnType, isNotNull);
     expect(functionType.typeParameters, isNull);
   }
 
   @failingTest
   void test_parseTypeAlias_genericFunction_typeParameters_noReturnType() {
     createParser('typedef F<T> = Function();');
     GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(typeAlias);
-    listener.assertNoErrors();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.typeParameters, isNotNull);
     expect(typeAlias.semicolon, isNotNull);
     GenericFunctionType functionType = typeAlias.functionType;
     expect(functionType, isNotNull);
     expect(functionType.parameters, isNotNull);
     expect(functionType.returnType, isNull);
     expect(functionType.typeParameters, isNull);
   }
 
   @failingTest
   void
       test_parseTypeAlias_genericFunction_typeParameters_parameterizedReturnType() {
     createParser('typedef F<T> = A<B> Function();');
     GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(typeAlias);
-    listener.assertNoErrors();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.typeParameters, isNotNull);
     expect(typeAlias.semicolon, isNotNull);
     GenericFunctionType functionType = typeAlias.functionType;
     expect(functionType, isNotNull);
     expect(functionType.parameters, isNotNull);
     expect(functionType.returnType, isNotNull);
     expect(functionType.typeParameters, isNull);
   }
 
   @failingTest
   void test_parseTypeAlias_genericFunction_typeParameters_parameters() {
     createParser('typedef F<T> = bool Function(Object value);');
     GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(typeAlias);
-    listener.assertNoErrors();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.typeParameters, isNotNull);
     expect(typeAlias.semicolon, isNotNull);
     GenericFunctionType functionType = typeAlias.functionType;
     expect(functionType, isNotNull);
     expect(functionType.parameters, isNotNull);
     expect(functionType.returnType, isNotNull);
     expect(functionType.typeParameters, isNull);
   }
 
   @failingTest
   void test_parseTypeAlias_genericFunction_typeParameters_typeParameters() {
     createParser('typedef F<T> = bool Function<E>();');
     GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(typeAlias);
-    listener.assertNoErrors();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.typeParameters, isNotNull);
     expect(typeAlias.semicolon, isNotNull);
     GenericFunctionType functionType = typeAlias.functionType;
     expect(functionType, isNotNull);
     expect(functionType.parameters, isNotNull);
     expect(functionType.returnType, isNotNull);
     expect(functionType.typeParameters, isNotNull);
   }
 
   @failingTest
   void test_parseTypeAlias_genericFunction_typeParameters_voidReturnType() {
     createParser('typedef F<T> = void Function();');
     GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(typeAlias);
-    listener.assertNoErrors();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.typeParameters, isNotNull);
     expect(typeAlias.semicolon, isNotNull);
     GenericFunctionType functionType = typeAlias.functionType;
     expect(functionType, isNotNull);
     expect(functionType.parameters, isNotNull);
     expect(functionType.returnType, isNotNull);
     expect(functionType.typeParameters, isNull);
   }
 
   @failingTest
   void test_parseTypeAlias_genericFunction_voidReturnType() {
     createParser('typedef F = void Function();');
     GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(typeAlias);
-    listener.assertNoErrors();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.typeParameters, isNull);
     expect(typeAlias.semicolon, isNotNull);
     GenericFunctionType functionType = typeAlias.functionType;
     expect(functionType, isNotNull);
     expect(functionType.parameters, isNotNull);
     expect(functionType.returnType, isNotNull);
     expect(functionType.typeParameters, isNull);
   }
-
-  /**
-   * Parse the given source as a compilation unit.
-   *
-   * @param source the source to be parsed
-   * @param errorCodes the error codes of the errors that are expected to be found
-   * @return the compilation unit that was parsed
-   * @throws Exception if the source could not be parsed, if the compilation errors in the source do
-   *           not match those that are expected, or if the result would have been `null`
-   */
-  CompilationUnit _parseDirectives(String source,
-      [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
-    createParser(source);
-    CompilationUnit unit = parser.parseDirectives2();
-    expect(unit, isNotNull);
-    expect(unit.declarations, hasLength(0));
-    listener.assertErrorsWithCodes(errorCodes);
-    return unit;
-  }
 }