diff --git a/pkg/analyzer/lib/src/test_utilities/ast_type_matchers.dart b/pkg/analyzer/lib/src/test_utilities/ast_type_matchers.dart
new file mode 100644
index 0000000..0ca336e
--- /dev/null
+++ b/pkg/analyzer/lib/src/test_utilities/ast_type_matchers.dart
@@ -0,0 +1,110 @@
+// Copyright (c) 2018, 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 'package:analyzer/dart/ast/ast.dart';
+import 'package:test/test.dart';
+
+const isAsExpression = const TypeMatcher<AsExpression>();
+
+const isAssertInitializer = const TypeMatcher<AssertInitializer>();
+
+const isAssignmentExpression = const TypeMatcher<AssignmentExpression>();
+
+const isAwaitExpression = const TypeMatcher<AwaitExpression>();
+
+const isBinaryExpression = const TypeMatcher<BinaryExpression>();
+
+const isBlock = const TypeMatcher<Block>();
+
+const isBlockFunctionBody = const TypeMatcher<BlockFunctionBody>();
+
+const isClassDeclaration = const TypeMatcher<ClassDeclaration>();
+
+const isClassTypeAlias = const TypeMatcher<ClassTypeAlias>();
+
+const isCompilationUnit = const TypeMatcher<CompilationUnit>();
+
+const isConditionalExpression = const TypeMatcher<ConditionalExpression>();
+
+const isConstructorDeclaration = const TypeMatcher<ConstructorDeclaration>();
+
+const isConstructorFieldInitializer =
+    const TypeMatcher<ConstructorFieldInitializer>();
+
+const isDefaultFormalParameter = const TypeMatcher<DefaultFormalParameter>();
+
+const isEmptyFunctionBody = const TypeMatcher<EmptyFunctionBody>();
+
+const isEmptyStatement = const TypeMatcher<EmptyStatement>();
+
+const isExpressionFunctionBody = const TypeMatcher<ExpressionFunctionBody>();
+
+const isExpressionStatement = const TypeMatcher<ExpressionStatement>();
+
+const isFieldDeclaration = const TypeMatcher<FieldDeclaration>();
+
+const isFieldFormalParameter = const TypeMatcher<FieldFormalParameter>();
+
+const isForStatement = const TypeMatcher<ForStatement>();
+
+const isFunctionDeclaration = const TypeMatcher<FunctionDeclaration>();
+
+const isFunctionDeclarationStatement =
+    const TypeMatcher<FunctionDeclarationStatement>();
+
+const isFunctionExpression = const TypeMatcher<FunctionExpression>();
+
+const isFunctionTypeAlias = const TypeMatcher<FunctionTypeAlias>();
+
+const isFunctionTypedFormalParameter =
+    const TypeMatcher<FunctionTypedFormalParameter>();
+
+const isGenericFunctionType = const TypeMatcher<GenericFunctionType>();
+
+const isIndexExpression = const TypeMatcher<IndexExpression>();
+
+const isInstanceCreationExpression =
+    const TypeMatcher<InstanceCreationExpression>();
+
+const isIntegerLiteral = const TypeMatcher<IntegerLiteral>();
+
+const isInterpolationExpression = const TypeMatcher<InterpolationExpression>();
+
+const isInterpolationString = const TypeMatcher<InterpolationString>();
+
+const isIsExpression = const TypeMatcher<IsExpression>();
+
+const isLibraryDirective = const TypeMatcher<LibraryDirective>();
+
+const isMethodDeclaration = const TypeMatcher<MethodDeclaration>();
+
+const isMethodInvocation = const TypeMatcher<MethodInvocation>();
+
+const isNullLiteral = const TypeMatcher<NullLiteral>();
+
+const isParenthesizedExpression = const TypeMatcher<ParenthesizedExpression>();
+
+const isPrefixedIdentifier = const TypeMatcher<PrefixedIdentifier>();
+
+const isPrefixExpression = const TypeMatcher<PrefixExpression>();
+
+const isPropertyAccess = const TypeMatcher<PropertyAccess>();
+
+const isReturnStatement = const TypeMatcher<ReturnStatement>();
+
+const isSimpleFormalParameter = const TypeMatcher<SimpleFormalParameter>();
+
+const isSimpleIdentifier = const TypeMatcher<SimpleIdentifier>();
+
+const isStringInterpolation = const TypeMatcher<StringInterpolation>();
+
+const isSuperExpression = const TypeMatcher<SuperExpression>();
+
+const isTopLevelVariableDeclaration =
+    const TypeMatcher<TopLevelVariableDeclaration>();
+
+const isTypeName = const TypeMatcher<TypeName>();
+
+const isVariableDeclarationStatement =
+    const TypeMatcher<VariableDeclarationStatement>();
diff --git a/pkg/analyzer/lib/src/test_utilities/element_type_matchers.dart b/pkg/analyzer/lib/src/test_utilities/element_type_matchers.dart
new file mode 100644
index 0000000..ac11f12
--- /dev/null
+++ b/pkg/analyzer/lib/src/test_utilities/element_type_matchers.dart
@@ -0,0 +1,30 @@
+// Copyright (c) 2018, 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 'package:analyzer/dart/element/element.dart';
+import 'package:test/test.dart';
+
+const isClassElement = const TypeMatcher<ClassElement>();
+
+const isCompilationUnitElement = const TypeMatcher<CompilationUnitElement>();
+
+const isConstructorElement = const TypeMatcher<ConstructorElement>();
+
+const isExportElement = const TypeMatcher<ExportElement>();
+
+const isFieldElement = const TypeMatcher<FieldElement>();
+
+const isFunctionElement = const TypeMatcher<FunctionElement>();
+
+const isImportElement = const TypeMatcher<ImportElement>();
+
+const isLibraryElement = const TypeMatcher<LibraryElement>();
+
+const isMethodElement = const TypeMatcher<MethodElement>();
+
+const isPropertyAccessorElement = const TypeMatcher<PropertyAccessorElement>();
+
+const isPropertyInducingElement = const TypeMatcher<PropertyInducingElement>();
+
+const isTopLevelVariableElement = const TypeMatcher<TopLevelVariableElement>();
diff --git a/pkg/analyzer/test/dart/ast/visitor_test.dart b/pkg/analyzer/test/dart/ast/visitor_test.dart
index 94457e0..0a8e8dd 100644
--- a/pkg/analyzer/test/dart/ast/visitor_test.dart
+++ b/pkg/analyzer/test/dart/ast/visitor_test.dart
@@ -4,11 +4,11 @@
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/src/test_utilities/ast_type_matchers.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../../generated/parser_test.dart' show ParserTestCase;
-import '../../generated/test_support.dart';
 
 main() {
   defineReflectiveSuite(() {
@@ -44,19 +44,11 @@
         new _BreadthFirstVisitorTestHelper(nodes);
     visitor.visitAllNodes(unit);
     expect(nodes, hasLength(59));
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is CompilationUnit, CompilationUnit, nodes[0]);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ClassDeclaration, ClassDeclaration, nodes[2]);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FunctionDeclaration, FunctionDeclaration, nodes[3]);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FunctionDeclarationStatement,
-        FunctionDeclarationStatement,
-        nodes[27]);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is IntegerLiteral, IntegerLiteral, nodes[58]);
-    //3
+    expect(nodes[0], isCompilationUnit);
+    expect(nodes[2], isClassDeclaration);
+    expect(nodes[3], isFunctionDeclaration);
+    expect(nodes[27], isFunctionDeclarationStatement);
+    expect(nodes[58], isIntegerLiteral); // 3
   }
 }
 
diff --git a/pkg/analyzer/test/dart/element/builder_test.dart b/pkg/analyzer/test/dart/element/builder_test.dart
index 4b6a746..b476b61 100644
--- a/pkg/analyzer/test/dart/element/builder_test.dart
+++ b/pkg/analyzer/test/dart/element/builder_test.dart
@@ -1948,9 +1948,7 @@
     expect(accessor.isSetter, isFalse);
     expect(accessor.isSynthetic, isFalse);
     expect(accessor.typeParameters, hasLength(0));
-    PropertyInducingElement variable = accessor.variable;
-    EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableElement,
-        TopLevelVariableElement, variable);
+    TopLevelVariableElement variable = accessor.variable;
     expect(variable.isSynthetic, isTrue);
   }
 
@@ -2012,9 +2010,7 @@
     expect(accessor.isSetter, isTrue);
     expect(accessor.isSynthetic, isFalse);
     expect(accessor.typeParameters, hasLength(0));
-    PropertyInducingElement variable = accessor.variable;
-    EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableElement,
-        TopLevelVariableElement, variable);
+    TopLevelVariableElement variable = accessor.variable;
     expect(variable.isSynthetic, isTrue);
   }
 
diff --git a/pkg/analyzer/test/generated/all_the_rest_test.dart b/pkg/analyzer/test/generated/all_the_rest_test.dart
index 49a4b02..f759a15 100644
--- a/pkg/analyzer/test/generated/all_the_rest_test.dart
+++ b/pkg/analyzer/test/generated/all_the_rest_test.dart
@@ -31,6 +31,7 @@
 import 'package:analyzer/src/generated/testing/test_type_provider.dart';
 import 'package:analyzer/src/generated/testing/token_factory.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
+import 'package:analyzer/src/test_utilities/element_type_matchers.dart';
 import 'package:analyzer/src/test_utilities/resource_provider_mixin.dart';
 import 'package:path/path.dart' as path;
 import 'package:source_span/source_span.dart';
@@ -187,22 +188,19 @@
   x += 1;
 }''');
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is MethodElement, MethodElement, element);
+    expect(element, isMethodElement);
   }
 
   test_locate_BinaryExpression() async {
     AstNode id = await _findNodeIn("+", "var x = 3 + 4;");
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is MethodElement, MethodElement, element);
+    expect(element, isMethodElement);
   }
 
   test_locate_ClassDeclaration() async {
     AstNode id = await _findNodeIn("class", "class A { }");
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ClassElement, ClassElement, element);
+    expect(element, isClassElement);
   }
 
   test_locate_CompilationUnit() async {
@@ -220,15 +218,13 @@
     ConstructorDeclaration declaration =
         id.thisOrAncestorOfType<ConstructorDeclaration>();
     Element element = ElementLocator.locate(declaration);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ConstructorElement, ConstructorElement, element);
+    expect(element, isConstructorElement);
   }
 
   test_locate_ExportDirective() async {
     AstNode id = await _findNodeIn("export", "export 'dart:core';");
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ExportElement, ExportElement, element);
+    expect(element, isExportElement);
   }
 
   test_locate_FunctionDeclaration() async {
@@ -236,8 +232,7 @@
     FunctionDeclaration declaration =
         id.thisOrAncestorOfType<FunctionDeclaration>();
     Element element = ElementLocator.locate(declaration);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FunctionElement, FunctionElement, element);
+    expect(element, isFunctionElement);
   }
 
   test_locate_Identifier_annotationClass_namedConstructor_forSimpleFormalParameter() async {
@@ -248,8 +243,7 @@
 void main(@Class.name() parameter) {
 }''');
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ClassElement, ClassElement, element);
+    expect(element, isClassElement);
   }
 
   test_locate_Identifier_annotationClass_unnamedConstructor_forSimpleFormalParameter() async {
@@ -260,15 +254,13 @@
 void main(@Class() parameter) {
 }''');
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ConstructorElement, ConstructorElement, element);
+    expect(element, isConstructorElement);
   }
 
   test_locate_Identifier_className() async {
     AstNode id = await _findNodeIn("A", "class A { }");
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ClassElement, ClassElement, element);
+    expect(element, isClassElement);
   }
 
   test_locate_Identifier_constructor_named() async {
@@ -277,8 +269,7 @@
   A.bar() {}
 }''');
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ConstructorElement, ConstructorElement, element);
+    expect(element, isConstructorElement);
   }
 
   test_locate_Identifier_constructor_unnamed() async {
@@ -287,22 +278,19 @@
   A() {}
 }''');
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ConstructorElement, ConstructorElement, element);
+    expect(element, isConstructorElement);
   }
 
   test_locate_Identifier_fieldName() async {
     AstNode id = await _findNodeIn("x", "class A { var x; }");
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FieldElement, FieldElement, element);
+    expect(element, isFieldElement);
   }
 
   test_locate_Identifier_libraryDirective() async {
     AstNode id = await _findNodeIn("foo", "library foo.bar;");
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is LibraryElement, LibraryElement, element);
+    expect(element, isLibraryElement);
   }
 
   test_locate_Identifier_propertyAccess() async {
@@ -311,15 +299,13 @@
  int x = 'foo'.length;
 }''');
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf((obj) => obj is PropertyAccessorElement,
-        PropertyAccessorElement, element);
+    expect(element, isPropertyAccessorElement);
   }
 
   test_locate_ImportDirective() async {
     AstNode id = await _findNodeIn("import", "import 'dart:core';");
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ImportElement, ImportElement, element);
+    expect(element, isImportElement);
   }
 
   test_locate_IndexExpression() async {
@@ -329,8 +315,7 @@
   var y = x[0];
 }''');
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is MethodElement, MethodElement, element);
+    expect(element, isMethodElement);
   }
 
   test_locate_InstanceCreationExpression() async {
@@ -340,8 +325,7 @@
  new A();
 }''');
     Element element = ElementLocator.locate(node);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ConstructorElement, ConstructorElement, element);
+    expect(element, isConstructorElement);
   }
 
   test_locate_InstanceCreationExpression_type_prefixedIdentifier() async {
@@ -385,8 +369,7 @@
   test_locate_LibraryDirective() async {
     AstNode id = await _findNodeIn("library", "library foo;");
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is LibraryElement, LibraryElement, element);
+    expect(element, isLibraryElement);
   }
 
   test_locate_MethodDeclaration() async {
@@ -397,8 +380,7 @@
     MethodDeclaration declaration =
         id.thisOrAncestorOfType<MethodDeclaration>();
     Element element = ElementLocator.locate(declaration);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is MethodElement, MethodElement, element);
+    expect(element, isMethodElement);
   }
 
   test_locate_MethodInvocation_method() async {
@@ -410,8 +392,7 @@
  var f = new A().bar();
 }''');
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is MethodElement, MethodElement, element);
+    expect(element, isMethodElement);
   }
 
   test_locate_MethodInvocation_topLevel() async {
@@ -425,8 +406,7 @@
     AstNode node = new NodeLocator(offset).searchWithin(cu);
     MethodInvocation invocation = node.thisOrAncestorOfType<MethodInvocation>();
     Element element = ElementLocator.locate(invocation);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FunctionElement, FunctionElement, element);
+    expect(element, isFunctionElement);
   }
 
   test_locate_PartOfDirective() async {
@@ -441,15 +421,13 @@
         analysisContext.resolveCompilationUnit2(unitSource, librarySource);
     PartOfDirective partOf = unit.directives.first;
     Element element = ElementLocator.locate(partOf);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is LibraryElement, LibraryElement, element);
+    expect(element, isLibraryElement);
   }
 
   test_locate_PostfixExpression() async {
     AstNode id = await _findNodeIn("++", "int addOne(int x) => x++;");
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is MethodElement, MethodElement, element);
+    expect(element, isMethodElement);
   }
 
   test_locate_PrefixedIdentifier() async {
@@ -459,23 +437,20 @@
     PrefixedIdentifier identifier =
         id.thisOrAncestorOfType<PrefixedIdentifier>();
     Element element = ElementLocator.locate(identifier);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ClassElement, ClassElement, element);
+    expect(element, isClassElement);
   }
 
   test_locate_PrefixExpression() async {
     AstNode id = await _findNodeIn("++", "int addOne(int x) => ++x;");
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is MethodElement, MethodElement, element);
+    expect(element, isMethodElement);
   }
 
   test_locate_StringLiteral_exportUri() async {
     addNamedSource("/foo.dart", "library foo;");
     AstNode id = await _findNodeIn("'foo.dart'", "export 'foo.dart';");
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is LibraryElement, LibraryElement, element);
+    expect(element, isLibraryElement);
   }
 
   test_locate_StringLiteral_expression() async {
@@ -489,8 +464,7 @@
     AstNode id = await _findNodeIn(
         "'foo.dart'", "import 'foo.dart'; class B extends A {}");
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is LibraryElement, LibraryElement, element);
+    expect(element, isLibraryElement);
   }
 
   test_locate_StringLiteral_partUri() async {
@@ -498,8 +472,7 @@
     AstNode id =
         await _findNodeIn("'foo.dart'", "library app; part 'foo.dart';");
     Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf((obj) => obj is CompilationUnitElement,
-        CompilationUnitElement, element);
+    expect(element, isCompilationUnitElement);
   }
 
   test_locate_VariableDeclaration() async {
@@ -507,8 +480,7 @@
     VariableDeclaration declaration =
         id.thisOrAncestorOfType<VariableDeclaration>();
     Element element = ElementLocator.locate(declaration);
-    EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableElement,
-        TopLevelVariableElement, element);
+    expect(element, isTopLevelVariableElement);
   }
 
   /**
diff --git a/pkg/analyzer/test/generated/constant_test.dart b/pkg/analyzer/test/generated/constant_test.dart
index 8c5dadf..12c9c85 100644
--- a/pkg/analyzer/test/generated/constant_test.dart
+++ b/pkg/analyzer/test/generated/constant_test.dart
@@ -15,7 +15,6 @@
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import 'resolver_test_case.dart';
-import 'test_support.dart';
 
 main() {
   defineReflectiveSuite(() {
@@ -478,11 +477,8 @@
         analysisContext.resolveCompilationUnit(source, library);
     expect(unit, isNotNull);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
-    CompilationUnitMember declaration = declarations[0];
-    EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableDeclaration,
-        TopLevelVariableDeclaration, declaration);
-    NodeList<VariableDeclaration> variables =
-        (declaration as TopLevelVariableDeclaration).variables.variables;
+    TopLevelVariableDeclaration declaration = declarations[0];
+    NodeList<VariableDeclaration> variables = declaration.variables.variables;
     expect(variables, hasLength(1));
     ConstantEvaluator evaluator = new ConstantEvaluator(
         source, analysisContext.typeProvider,
diff --git a/pkg/analyzer/test/generated/element_resolver_test.dart b/pkg/analyzer/test/generated/element_resolver_test.dart
index e553c30..1404256 100644
--- a/pkg/analyzer/test/generated/element_resolver_test.dart
+++ b/pkg/analyzer/test/generated/element_resolver_test.dart
@@ -1049,10 +1049,8 @@
     AstTestFactory.assignmentExpression(
         node, TokenType.EQ, AstTestFactory.integer(0));
     _resolveInClass(node, classA);
-    Element element = node.staticElement;
-    EngineTestCase.assertInstanceOf((obj) => obj is PropertyAccessorElement,
-        PropertyAccessorElement, element);
-    expect((element as PropertyAccessorElement).isSetter, isTrue);
+    PropertyAccessorElement element = node.staticElement;
+    expect(element.isSetter, isTrue);
     _listener.assertNoErrors();
   }
 
diff --git a/pkg/analyzer/test/generated/parser_test.dart b/pkg/analyzer/test/generated/parser_test.dart
index 8b8b575..c86688b 100644
--- a/pkg/analyzer/test/generated/parser_test.dart
+++ b/pkg/analyzer/test/generated/parser_test.dart
@@ -24,6 +24,7 @@
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
+import 'package:analyzer/src/test_utilities/ast_type_matchers.dart';
 import 'test_support.dart';
 
 main() {
@@ -341,17 +342,14 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     FunctionBody body = method.body;
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is BlockFunctionBody, BlockFunctionBody, body);
+    expect(body, isBlockFunctionBody);
     Statement statement = (body as BlockFunctionBody).block.statements[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ExpressionStatement, ExpressionStatement, statement);
+    expect(statement, isExpressionStatement);
     Expression expression = (statement as ExpressionStatement).expression;
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is AwaitExpression, AwaitExpression, expression);
+    expect(expression, isAwaitExpression);
     expect((expression as AwaitExpression).awaitKeyword, isNotNull);
     expect((expression as AwaitExpression).expression, isNotNull);
   }
@@ -361,16 +359,12 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     FunctionBody body = method.body;
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is BlockFunctionBody, BlockFunctionBody, body);
+    expect(body, isBlockFunctionBody);
     Statement statement = (body as BlockFunctionBody).block.statements[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is VariableDeclarationStatement,
-        VariableDeclarationStatement,
-        statement);
+    expect(statement, isVariableDeclarationStatement);
   }
 
   void test_parseAwaitExpression_inSync() {
@@ -391,20 +385,15 @@
             expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 29, 1)
           ]);
     FunctionBody body = method.body;
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is BlockFunctionBody, BlockFunctionBody, body);
+    expect(body, isBlockFunctionBody);
     Statement statement = (body as BlockFunctionBody).block.statements[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ReturnStatement, ReturnStatement, statement);
+    expect(statement, isReturnStatement);
     Expression expression = (statement as ReturnStatement).expression;
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is BinaryExpression, BinaryExpression, expression);
+    expect(expression, isBinaryExpression);
     if (!usingFastaParser) {
       // TODO(danrubel): capture `await` keywords in fasta generated AST
-      EngineTestCase.assertInstanceOf((obj) => obj is AwaitExpression,
-          AwaitExpression, (expression as BinaryExpression).leftOperand);
-      EngineTestCase.assertInstanceOf((obj) => obj is AwaitExpression,
-          AwaitExpression, (expression as BinaryExpression).rightOperand);
+      expect((expression as BinaryExpression).leftOperand, isAwaitExpression);
+      expect((expression as BinaryExpression).rightOperand, isAwaitExpression);
     }
   }
 
@@ -421,7 +410,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ConstructorDeclaration>());
+    expect(member, isConstructorDeclaration);
     ConstructorDeclaration constructor = member;
     expect(constructor.body, isNotNull);
     expect(constructor.separator, isNotNull);
@@ -440,7 +429,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FieldDeclaration>());
+    expect(member, isFieldDeclaration);
     FieldDeclaration field = member;
     expect(field.covariantKeyword, isNotNull);
     expect(field.documentationComment, isNull);
@@ -459,7 +448,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FieldDeclaration>());
+    expect(member, isFieldDeclaration);
     FieldDeclaration field = member;
     expect(field.covariantKeyword, isNull);
     expect(field.documentationComment, isNull);
@@ -489,9 +478,9 @@
 ''');
     ClassMember member = parser.parseClassMember('C');
     assertNoErrors();
-    expect(member, new TypeMatcher<FieldDeclaration>());
+    expect(member, isFieldDeclaration);
     VariableDeclarationList fields = (member as FieldDeclaration).fields;
-    expect(fields.type, new TypeMatcher<GenericFunctionType>());
+    expect(fields.type, isGenericFunctionType);
   }
 
   void test_parseClassMember_field_gftType_noReturnType() {
@@ -500,9 +489,9 @@
 ''');
     ClassMember member = parser.parseClassMember('C');
     assertNoErrors();
-    expect(member, new TypeMatcher<FieldDeclaration>());
+    expect(member, isFieldDeclaration);
     VariableDeclarationList fields = (member as FieldDeclaration).fields;
-    expect(fields.type, new TypeMatcher<GenericFunctionType>());
+    expect(fields.type, isGenericFunctionType);
   }
 
   void test_parseClassMember_field_instance_prefixedType() {
@@ -510,7 +499,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FieldDeclaration>());
+    expect(member, isFieldDeclaration);
     FieldDeclaration field = member;
     expect(field.covariantKeyword, isNull);
     expect(field.documentationComment, isNull);
@@ -530,7 +519,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FieldDeclaration>());
+    expect(member, isFieldDeclaration);
     FieldDeclaration field = member;
     expect(field.covariantKeyword, isNull);
     expect(field.documentationComment, isNull);
@@ -549,7 +538,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FieldDeclaration>());
+    expect(member, isFieldDeclaration);
     FieldDeclaration field = member;
     expect(field.covariantKeyword, isNull);
     expect(field.documentationComment, isNull);
@@ -568,7 +557,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FieldDeclaration>());
+    expect(member, isFieldDeclaration);
     FieldDeclaration field = member;
     expect(field.covariantKeyword, isNull);
     expect(field.documentationComment, isNull);
@@ -588,7 +577,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FieldDeclaration>());
+    expect(member, isFieldDeclaration);
     FieldDeclaration field = member;
     expect(field.covariantKeyword, isNull);
     expect(field.documentationComment, isNull);
@@ -639,7 +628,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FieldDeclaration>());
+    expect(member, isFieldDeclaration);
     FieldDeclaration field = member;
     expect(field.covariantKeyword, isNull);
     expect(field.documentationComment, isNull);
@@ -658,7 +647,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -676,7 +665,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -695,7 +684,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNotNull);
@@ -719,7 +708,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.body, isNotNull);
     expect(method.documentationComment, isNull);
@@ -738,7 +727,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -757,7 +746,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -783,7 +772,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -802,7 +791,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -825,7 +814,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -855,7 +844,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -875,7 +864,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -894,7 +883,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -913,7 +902,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -932,7 +921,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -951,7 +940,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -971,9 +960,8 @@
 ''');
     ClassMember member = parser.parseClassMember('C');
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
-    expect((member as MethodDeclaration).body,
-        new TypeMatcher<ExpressionFunctionBody>());
+    expect(member, isMethodDeclaration);
+    expect((member as MethodDeclaration).body, isExpressionFunctionBody);
   }
 
   void test_parseClassMember_method_gftReturnType_voidReturnType() {
@@ -982,9 +970,8 @@
 ''');
     ClassMember member = parser.parseClassMember('C');
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
-    expect((member as MethodDeclaration).body,
-        new TypeMatcher<ExpressionFunctionBody>());
+    expect(member, isMethodDeclaration);
+    expect((member as MethodDeclaration).body, isExpressionFunctionBody);
   }
 
   void test_parseClassMember_method_native_allowed() {
@@ -1066,7 +1053,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -1085,7 +1072,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -1104,7 +1091,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -1123,7 +1110,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -1143,7 +1130,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -1162,7 +1149,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -1181,7 +1168,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -1200,7 +1187,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -1219,7 +1206,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -1272,7 +1259,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -1291,21 +1278,21 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
-    expect(method.returnType, new TypeMatcher<GenericFunctionType>());
+    expect(method.returnType, isGenericFunctionType);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNotNull);
     expect(method.typeParameters, isNull);
     expect(method.parameters, isNotNull);
     NodeList<FormalParameter> parameters = method.parameters.parameters;
     expect(parameters, hasLength(1));
-    expect((parameters[0] as SimpleFormalParameter).type,
-        new TypeMatcher<GenericFunctionType>());
+    expect(
+        (parameters[0] as SimpleFormalParameter).type, isGenericFunctionType);
     expect(method.body, isNotNull);
   }
 
@@ -1314,7 +1301,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -1333,7 +1320,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -1352,7 +1339,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
@@ -1386,7 +1373,7 @@
     expect(constructor.redirectedConstructor.type.name.name, 'prefix.B');
     expect(constructor.redirectedConstructor.period.type, TokenType.PERIOD);
     expect(constructor.redirectedConstructor.name.name, 'foo');
-    expect(constructor.body, new TypeMatcher<EmptyFunctionBody>());
+    expect(constructor.body, isEmptyFunctionBody);
   }
 
   void test_parseClassMember_redirectingFactory_expressionBody() {
@@ -1419,7 +1406,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ConstructorDeclaration>());
+    expect(member, isConstructorDeclaration);
     ConstructorDeclaration constructor = member;
     expect(constructor.externalKeyword, isNull);
     expect(constructor.constKeyword, isNull);
@@ -1436,7 +1423,7 @@
     expect(constructor.redirectedConstructor.type.name.name, 'B');
     expect(constructor.redirectedConstructor.period, isNull);
     expect(constructor.redirectedConstructor.name, isNull);
-    expect(constructor.body, new TypeMatcher<EmptyFunctionBody>());
+    expect(constructor.body, isEmptyFunctionBody);
   }
 
   void test_parseConstructor_assert() {
@@ -1444,12 +1431,12 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ConstructorDeclaration>());
+    expect(member, isConstructorDeclaration);
     ConstructorDeclaration constructor = member as ConstructorDeclaration;
     NodeList<ConstructorInitializer> initializers = constructor.initializers;
     expect(initializers, hasLength(3));
     ConstructorInitializer initializer = initializers[1];
-    expect(initializer, new TypeMatcher<AssertInitializer>());
+    expect(initializer, isAssertInitializer);
     AssertInitializer assertInitializer = initializer;
     expect(assertInitializer.condition, isNotNull);
     expect(assertInitializer.message, isNull);
@@ -1483,7 +1470,7 @@
     expect(constructor.separator, isNull);
     expect(constructor.initializers, isEmpty);
     expect(constructor.redirectedConstructor, isNull);
-    expect(constructor.body, new TypeMatcher<ExpressionFunctionBody>());
+    expect(constructor.body, isExpressionFunctionBody);
   }
 
   void test_parseConstructor_initializers_field() {
@@ -1491,7 +1478,7 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ConstructorDeclaration>());
+    expect(member, isConstructorDeclaration);
     ConstructorDeclaration constructor = member as ConstructorDeclaration;
     NodeList<ConstructorInitializer> initializers = constructor.initializers;
     expect(initializers, hasLength(2));
@@ -1531,7 +1518,7 @@
     expect(constructor.separator, isNull);
     expect(constructor.initializers, isEmpty);
     expect(constructor.redirectedConstructor, isNull);
-    expect(constructor.body, new TypeMatcher<EmptyFunctionBody>());
+    expect(constructor.body, isEmptyFunctionBody);
   }
 
   void test_parseConstructor_unnamed() {
@@ -1551,7 +1538,7 @@
     expect(constructor.separator, isNull);
     expect(constructor.initializers, isEmpty);
     expect(constructor.redirectedConstructor, isNull);
-    expect(constructor.body, new TypeMatcher<EmptyFunctionBody>());
+    expect(constructor.body, isEmptyFunctionBody);
   }
 
   void test_parseConstructor_with_pseudo_function_literal() {
@@ -1561,19 +1548,15 @@
     ClassMember member = parser.parseClassMember('C');
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ConstructorDeclaration>());
+    expect(member, isConstructorDeclaration);
     ConstructorDeclaration constructor = member as ConstructorDeclaration;
     NodeList<ConstructorInitializer> initializers = constructor.initializers;
     expect(initializers, hasLength(1));
     ConstructorInitializer initializer = initializers[0];
-    EngineTestCase.assertInstanceOf((obj) => obj is ConstructorFieldInitializer,
-        ConstructorFieldInitializer, initializer);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ParenthesizedExpression,
-        ParenthesizedExpression,
-        (initializer as ConstructorFieldInitializer).expression);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is BlockFunctionBody, BlockFunctionBody, constructor.body);
+    expect(initializer, isConstructorFieldInitializer);
+    expect((initializer as ConstructorFieldInitializer).expression,
+        isParenthesizedExpression);
+    expect(constructor.body, isBlockFunctionBody);
   }
 
   void test_parseConstructorFieldInitializer_qualified() {
@@ -1774,40 +1757,33 @@
 mixin ComplexParserTestMixin implements AbstractParserTestCase {
   void test_additiveExpression_normal() {
     BinaryExpression expression = parseExpression("x + y - z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_additiveExpression_noSpaces() {
     BinaryExpression expression = parseExpression("i+1");
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftOperand);
-    EngineTestCase.assertInstanceOf((obj) => obj is IntegerLiteral,
-        IntegerLiteral, expression.rightOperand);
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.rightOperand, isIntegerLiteral);
   }
 
   void test_additiveExpression_precedence_multiplicative_left() {
     BinaryExpression expression = parseExpression("x * y + z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_additiveExpression_precedence_multiplicative_left_withSuper() {
     BinaryExpression expression = parseExpression("super * y - z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_additiveExpression_precedence_multiplicative_right() {
     BinaryExpression expression = parseExpression("x + y * z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.rightOperand);
+    expect(expression.rightOperand, isBinaryExpression);
   }
 
   void test_additiveExpression_super() {
     BinaryExpression expression = parseExpression("super + y - z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_assignableExpression_arguments_normal_chain() {
@@ -1816,10 +1792,7 @@
     //
     // a(b)(c).d(e)
     //
-    MethodInvocation invocation2 = EngineTestCase.assertInstanceOf(
-        (obj) => obj is MethodInvocation,
-        MethodInvocation,
-        propertyAccess1.target);
+    MethodInvocation invocation2 = propertyAccess1.target;
     expect(invocation2.methodName.name, "d");
     expect(invocation2.typeArguments, isNull);
     ArgumentList argumentList2 = invocation2.argumentList;
@@ -1828,10 +1801,7 @@
     //
     // a(b)(c)
     //
-    FunctionExpressionInvocation invocation3 = EngineTestCase.assertInstanceOf(
-        (obj) => obj is FunctionExpressionInvocation,
-        FunctionExpressionInvocation,
-        invocation2.target);
+    FunctionExpressionInvocation invocation3 = invocation2.target;
     expect(invocation3.typeArguments, isNull);
     ArgumentList argumentList3 = invocation3.argumentList;
     expect(argumentList3, isNotNull);
@@ -1839,10 +1809,7 @@
     //
     // a(b)
     //
-    MethodInvocation invocation4 = EngineTestCase.assertInstanceOf(
-        (obj) => obj is MethodInvocation,
-        MethodInvocation,
-        invocation3.function);
+    MethodInvocation invocation4 = invocation3.function;
     expect(invocation4.methodName.name, "a");
     expect(invocation4.typeArguments, isNull);
     ArgumentList argumentList4 = invocation4.argumentList;
@@ -1857,106 +1824,86 @@
 
   void test_assignmentExpression_compound() {
     AssignmentExpression expression = parseExpression("x = y = 0");
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftHandSide);
-    EngineTestCase.assertInstanceOf((obj) => obj is AssignmentExpression,
-        AssignmentExpression, expression.rightHandSide);
+    expect(expression.leftHandSide, isSimpleIdentifier);
+    expect(expression.rightHandSide, isAssignmentExpression);
   }
 
   void test_assignmentExpression_indexExpression() {
     AssignmentExpression expression = parseExpression("x[1] = 0");
-    EngineTestCase.assertInstanceOf((obj) => obj is IndexExpression,
-        IndexExpression, expression.leftHandSide);
-    EngineTestCase.assertInstanceOf((obj) => obj is IntegerLiteral,
-        IntegerLiteral, expression.rightHandSide);
+    expect(expression.leftHandSide, isIndexExpression);
+    expect(expression.rightHandSide, isIntegerLiteral);
   }
 
   void test_assignmentExpression_prefixedIdentifier() {
     AssignmentExpression expression = parseExpression("x.y = 0");
-    EngineTestCase.assertInstanceOf((obj) => obj is PrefixedIdentifier,
-        PrefixedIdentifier, expression.leftHandSide);
-    EngineTestCase.assertInstanceOf((obj) => obj is IntegerLiteral,
-        IntegerLiteral, expression.rightHandSide);
+    expect(expression.leftHandSide, isPrefixedIdentifier);
+    expect(expression.rightHandSide, isIntegerLiteral);
   }
 
   void test_assignmentExpression_propertyAccess() {
     AssignmentExpression expression = parseExpression("super.y = 0");
-    EngineTestCase.assertInstanceOf((obj) => obj is PropertyAccess,
-        PropertyAccess, expression.leftHandSide);
-    EngineTestCase.assertInstanceOf((obj) => obj is IntegerLiteral,
-        IntegerLiteral, expression.rightHandSide);
+    expect(expression.leftHandSide, isPropertyAccess);
+    expect(expression.rightHandSide, isIntegerLiteral);
   }
 
   void test_bitwiseAndExpression_normal() {
     BinaryExpression expression = parseExpression("x & y & z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_bitwiseAndExpression_precedence_equality_left() {
     BinaryExpression expression = parseExpression("x == y && z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_bitwiseAndExpression_precedence_equality_right() {
     BinaryExpression expression = parseExpression("x && y == z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.rightOperand);
+    expect(expression.rightOperand, isBinaryExpression);
   }
 
   void test_bitwiseAndExpression_super() {
     BinaryExpression expression = parseExpression("super & y & z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_bitwiseOrExpression_normal() {
     BinaryExpression expression = parseExpression("x | y | z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_bitwiseOrExpression_precedence_xor_left() {
     BinaryExpression expression = parseExpression("x ^ y | z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_bitwiseOrExpression_precedence_xor_right() {
     BinaryExpression expression = parseExpression("x | y ^ z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.rightOperand);
+    expect(expression.rightOperand, isBinaryExpression);
   }
 
   void test_bitwiseOrExpression_super() {
     BinaryExpression expression = parseExpression("super | y | z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_bitwiseXorExpression_normal() {
     BinaryExpression expression = parseExpression("x ^ y ^ z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_bitwiseXorExpression_precedence_and_left() {
     BinaryExpression expression = parseExpression("x & y ^ z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_bitwiseXorExpression_precedence_and_right() {
     BinaryExpression expression = parseExpression("x ^ y & z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.rightOperand);
+    expect(expression.rightOperand, isBinaryExpression);
   }
 
   void test_bitwiseXorExpression_super() {
     BinaryExpression expression = parseExpression("super ^ y ^ z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_cascade_withAssignment() {
@@ -1964,11 +1911,9 @@
         parseExpression("new Map()..[3] = 4 ..[0] = 11");
     Expression target = cascade.target;
     for (Expression section in cascade.cascadeSections) {
-      EngineTestCase.assertInstanceOf(
-          (obj) => obj is AssignmentExpression, AssignmentExpression, section);
+      expect(section, isAssignmentExpression);
       Expression lhs = (section as AssignmentExpression).leftHandSide;
-      EngineTestCase.assertInstanceOf(
-          (obj) => obj is IndexExpression, IndexExpression, lhs);
+      expect(lhs, isIndexExpression);
       IndexExpression index = lhs as IndexExpression;
       expect(index.isCascaded, isTrue);
       expect(index.realTarget, same(target));
@@ -1977,40 +1922,38 @@
 
   void test_conditionalExpression_precedence_ifNullExpression() {
     ConditionalExpression expression = parseExpression('a ?? b ? y : z');
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.condition);
+    expect(expression.condition, isBinaryExpression);
   }
 
   void test_conditionalExpression_precedence_logicalOrExpression() {
     ConditionalExpression expression = parseExpression("a | b ? y : z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.condition);
+    expect(expression.condition, isBinaryExpression);
   }
 
   void test_conditionalExpression_precedence_nullableType_as() {
     Expression expression = parseExpression('x as String ? (x + y) : z');
     expect(expression, isNotNull);
-    expect(expression, new TypeMatcher<ConditionalExpression>());
+    expect(expression, isConditionalExpression);
     ConditionalExpression conditional = expression;
     Expression condition = conditional.condition;
-    expect(condition, new TypeMatcher<AsExpression>());
+    expect(condition, isAsExpression);
     Expression thenExpression = conditional.thenExpression;
-    expect(thenExpression, new TypeMatcher<ParenthesizedExpression>());
+    expect(thenExpression, isParenthesizedExpression);
     Expression elseExpression = conditional.elseExpression;
-    expect(elseExpression, new TypeMatcher<SimpleIdentifier>());
+    expect(elseExpression, isSimpleIdentifier);
   }
 
   void test_conditionalExpression_precedence_nullableType_is() {
     Expression expression = parseExpression('x is String ? (x + y) : z');
     expect(expression, isNotNull);
-    expect(expression, new TypeMatcher<ConditionalExpression>());
+    expect(expression, isConditionalExpression);
     ConditionalExpression conditional = expression;
     Expression condition = conditional.condition;
-    expect(condition, new TypeMatcher<IsExpression>());
+    expect(condition, isIsExpression);
     Expression thenExpression = conditional.thenExpression;
-    expect(thenExpression, new TypeMatcher<ParenthesizedExpression>());
+    expect(thenExpression, isParenthesizedExpression);
     Expression elseExpression = conditional.elseExpression;
-    expect(elseExpression, new TypeMatcher<SimpleIdentifier>());
+    expect(elseExpression, isSimpleIdentifier);
   }
 
   void test_constructor_initializer_withParenthesizedExpression() {
@@ -2027,83 +1970,75 @@
   void test_equalityExpression_normal() {
     BinaryExpression expression = parseExpression("x == y != z",
         codes: [ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_equalityExpression_precedence_relational_left() {
     BinaryExpression expression = parseExpression("x is y == z");
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is IsExpression, IsExpression, expression.leftOperand);
+    expect(expression.leftOperand, isIsExpression);
   }
 
   void test_equalityExpression_precedence_relational_right() {
     BinaryExpression expression = parseExpression("x == y is z");
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is IsExpression, IsExpression, expression.rightOperand);
+    expect(expression.rightOperand, isIsExpression);
   }
 
   void test_equalityExpression_super() {
     BinaryExpression expression = parseExpression("super == y != z",
         codes: [ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_ifNullExpression() {
     BinaryExpression expression = parseExpression('x ?? y ?? z');
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_ifNullExpression_precedence_logicalOr_left() {
     BinaryExpression expression = parseExpression('x || y ?? z');
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_ifNullExpression_precedence_logicalOr_right() {
     BinaryExpression expression = parseExpression('x ?? y || z');
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.rightOperand);
+    expect(expression.rightOperand, isBinaryExpression);
   }
 
   void test_logicalAndExpression() {
     BinaryExpression expression = parseExpression("x && y && z");
-    expect(expression.leftOperand, new TypeMatcher<BinaryExpression>());
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_logicalAndExpression_precedence_bitwiseOr_left() {
     BinaryExpression expression = parseExpression("x | y < z");
-    expect(expression.leftOperand, new TypeMatcher<BinaryExpression>());
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_logicalAndExpression_precedence_bitwiseOr_right() {
     BinaryExpression expression = parseExpression("x < y | z");
-    expect(expression.rightOperand, new TypeMatcher<BinaryExpression>());
+    expect(expression.rightOperand, isBinaryExpression);
   }
 
   void test_logicalAndExpressionStatement() {
     // Assert that `<` and `>` are not interpreted as type arguments.
     ExpressionStatement statement = parseStatement("C<T && T>U;");
     BinaryExpression expression = statement.expression;
-    expect(expression.leftOperand, new TypeMatcher<BinaryExpression>());
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_logicalOrExpression() {
     BinaryExpression expression = parseExpression("x || y || z");
-    expect(expression.leftOperand, new TypeMatcher<BinaryExpression>());
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_logicalOrExpression_precedence_logicalAnd_left() {
     BinaryExpression expression = parseExpression("x && y || z");
-    expect(expression.leftOperand, new TypeMatcher<BinaryExpression>());
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_logicalOrExpression_precedence_logicalAnd_right() {
     BinaryExpression expression = parseExpression("x || y && z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.rightOperand);
+    expect(expression.rightOperand, isBinaryExpression);
   }
 
   void test_methodInvocation1() {
@@ -2133,62 +2068,52 @@
   void test_multipleLabels_statement() {
     LabeledStatement statement = parseStatement("a: b: c: return x;");
     expect(statement.labels, hasLength(3));
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ReturnStatement, ReturnStatement, statement.statement);
+    expect(statement.statement, isReturnStatement);
   }
 
   void test_multiplicativeExpression_normal() {
     BinaryExpression expression = parseExpression("x * y / z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_multiplicativeExpression_precedence_unary_left() {
     BinaryExpression expression = parseExpression("-x * y");
-    EngineTestCase.assertInstanceOf((obj) => obj is PrefixExpression,
-        PrefixExpression, expression.leftOperand);
+    expect(expression.leftOperand, isPrefixExpression);
   }
 
   void test_multiplicativeExpression_precedence_unary_right() {
     BinaryExpression expression = parseExpression("x * -y");
-    EngineTestCase.assertInstanceOf((obj) => obj is PrefixExpression,
-        PrefixExpression, expression.rightOperand);
+    expect(expression.rightOperand, isPrefixExpression);
   }
 
   void test_multiplicativeExpression_super() {
     BinaryExpression expression = parseExpression("super * y / z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_relationalExpression_precedence_shift_right() {
     IsExpression expression = parseExpression("x << y is z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.expression);
+    expect(expression.expression, isBinaryExpression);
   }
 
   void test_shiftExpression_normal() {
     BinaryExpression expression = parseExpression("x >> 4 << 3");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_shiftExpression_precedence_additive_left() {
     BinaryExpression expression = parseExpression("x + y << z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_shiftExpression_precedence_additive_right() {
     BinaryExpression expression = parseExpression("x << y + z");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.rightOperand);
+    expect(expression.rightOperand, isBinaryExpression);
   }
 
   void test_shiftExpression_super() {
     BinaryExpression expression = parseExpression("super >> 4 << 3");
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_topLevelFunction_nestedGenericFunction() {
@@ -2208,10 +2133,7 @@
     //
     // a<E>(b)<F>(c).d<G>(e)
     //
-    MethodInvocation invocation2 = EngineTestCase.assertInstanceOf(
-        (obj) => obj is MethodInvocation,
-        MethodInvocation,
-        propertyAccess1.target);
+    MethodInvocation invocation2 = propertyAccess1.target;
     expect(invocation2.methodName.name, "d");
     expect(invocation2.typeArguments, isNotNull);
     ArgumentList argumentList2 = invocation2.argumentList;
@@ -2220,10 +2142,7 @@
     //
     // a<E>(b)<F>(c)
     //
-    FunctionExpressionInvocation invocation3 = EngineTestCase.assertInstanceOf(
-        (obj) => obj is FunctionExpressionInvocation,
-        FunctionExpressionInvocation,
-        invocation2.target);
+    FunctionExpressionInvocation invocation3 = invocation2.target;
     expect(invocation3.typeArguments, isNotNull);
     ArgumentList argumentList3 = invocation3.argumentList;
     expect(argumentList3, isNotNull);
@@ -2231,10 +2150,7 @@
     //
     // a(b)
     //
-    MethodInvocation invocation4 = EngineTestCase.assertInstanceOf(
-        (obj) => obj is MethodInvocation,
-        MethodInvocation,
-        invocation3.function);
+    MethodInvocation invocation4 = invocation3.function;
     expect(invocation4.methodName.name, "a");
     expect(invocation4.typeArguments, isNotNull);
     ArgumentList argumentList4 = invocation4.argumentList;
@@ -4259,7 +4175,7 @@
             expectedError(ParserErrorCode.EXPECTED_TOKEN, 0, 0), // close paren
             expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 0, 0)
           ]);
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(
         method.parameters.toString(), usingFastaParser ? '(E)' : '(E, extends)',
@@ -4279,7 +4195,7 @@
             expectedError(ParserErrorCode.EXPECTED_TOKEN, 0, 0) /*)*/,
             expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 0, 0)
           ]);
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.typeParameters.toString(), '<E, hello>',
         reason: 'parser recovers what it can');
@@ -4313,7 +4229,7 @@
     BlockFunctionBody blockBody = declaration.functionExpression.body;
     ExpressionStatement statement = (blockBody).block.statements.first;
     Expression expression = (statement).expression;
-    expect(expression, new TypeMatcher<SuperExpression>());
+    expect(expression, isSuperExpression);
     SuperExpression superExpression = expression;
     expect(superExpression.superKeyword, isNotNull);
   }
@@ -4583,7 +4499,7 @@
       expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS,
           usingFastaParser ? 5 : 7, 1)
     ]);
-    expect(member, new TypeMatcher<MethodDeclaration>());
+    expect(member, isMethodDeclaration);
     MethodDeclaration method = member;
     expect(method.parameters, hasLength(0));
   }
@@ -4840,14 +4756,14 @@
       expression = parser.parsePrimaryExpression();
       listener.assertErrors(
           [expectedError(ParserErrorCode.NAMED_FUNCTION_EXPRESSION, 0, 1)]);
-      expect(expression, new TypeMatcher<FunctionExpression>());
+      expect(expression, isFunctionExpression);
     } else {
       expression = parsePrimaryExpression('f() {}');
       expectNotNullIfNoErrors(expression);
       // Should generate an error.
       //listener.assertErrors(
       //    [expectedError(ParserErrorCode.NAMED_FUNCTION_EXPRESSION, 0, 1)]);
-      //expect(expression, new TypeMatcher<FunctionExpression>());
+      //expect(expression, isFunctionExpression);
     }
   }
 
@@ -5271,7 +5187,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expectNotNullIfNoErrors(member);
     assertNoErrors();
-    expect(member, new TypeMatcher<FunctionDeclaration>());
+    expect(member, isFunctionDeclaration);
     FunctionDeclaration function = member;
     expect(function.functionExpression.parameters, isNull);
   }
@@ -5774,7 +5690,7 @@
     expect(expression, isNotNull);
     assertNoErrors();
     var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, new TypeMatcher<SuperExpression>());
+    expect(binaryExpression.leftOperand, isSuperExpression);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.PLUS);
     expect(binaryExpression.rightOperand, isNotNull);
@@ -5918,8 +5834,7 @@
     expect(expression, isNotNull);
     assertNoErrors();
     var propertyAccess = expression as PropertyAccess;
-    EngineTestCase.assertInstanceOf((obj) => obj is SuperExpression,
-        SuperExpression, propertyAccess.target);
+    expect(propertyAccess.target, isSuperExpression);
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
@@ -5929,7 +5844,7 @@
     expect(expression, isNotNull);
     assertNoErrors();
     var indexExpression = expression as IndexExpression;
-    expect(indexExpression.target, new TypeMatcher<SuperExpression>());
+    expect(indexExpression.target, isSuperExpression);
     expect(indexExpression.leftBracket, isNotNull);
     expect(indexExpression.index, isNotNull);
     expect(indexExpression.rightBracket, isNotNull);
@@ -5995,7 +5910,7 @@
     expect(expression, isNotNull);
     assertNoErrors();
     var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, new TypeMatcher<SuperExpression>());
+    expect(binaryExpression.leftOperand, isSuperExpression);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.AMPERSAND);
     expect(binaryExpression.rightOperand, isNotNull);
@@ -6017,7 +5932,7 @@
     expect(expression, isNotNull);
     assertNoErrors();
     var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, new TypeMatcher<SuperExpression>());
+    expect(binaryExpression.leftOperand, isSuperExpression);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.BAR);
     expect(binaryExpression.rightOperand, isNotNull);
@@ -6039,7 +5954,7 @@
     expect(expression, isNotNull);
     assertNoErrors();
     var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, new TypeMatcher<SuperExpression>());
+    expect(binaryExpression.leftOperand, isSuperExpression);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.CARET);
     expect(binaryExpression.rightOperand, isNotNull);
@@ -6061,7 +5976,7 @@
     expect(expression, isNotNull);
     assertNoErrors();
     var section = expression as FunctionExpressionInvocation;
-    expect(section.function, new TypeMatcher<IndexExpression>());
+    expect(section.function, isIndexExpression);
     expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
   }
@@ -6071,7 +5986,7 @@
     expect(expression, isNotNull);
     assertNoErrors();
     var section = expression as FunctionExpressionInvocation;
-    expect(section.function, new TypeMatcher<IndexExpression>());
+    expect(section.function, isIndexExpression);
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
   }
@@ -6081,7 +5996,7 @@
     expect(expression, isNotNull);
     assertNoErrors();
     var section = expression as MethodInvocation;
-    expect(section.target, new TypeMatcher<MethodInvocation>());
+    expect(section.target, isMethodInvocation);
     expect(section.operator, isNotNull);
     expect(section.methodName, isNotNull);
     expect(section.typeArguments, isNull);
@@ -6094,7 +6009,7 @@
     expect(expression, isNotNull);
     assertNoErrors();
     var section = expression as MethodInvocation;
-    expect(section.target, new TypeMatcher<MethodInvocation>());
+    expect(section.target, isMethodInvocation);
     expect(section.operator, isNotNull);
     expect(section.methodName, isNotNull);
     expect(section.typeArguments, isNotNull);
@@ -6131,8 +6046,7 @@
     expect(section.leftHandSide, isNotNull);
     expect(section.operator, isNotNull);
     Expression rhs = section.rightHandSide;
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is IntegerLiteral, IntegerLiteral, rhs);
+    expect(rhs, isIntegerLiteral);
   }
 
   void test_parseCascadeSection_p_assign_withCascade_typeArguments() {
@@ -6143,8 +6057,7 @@
     expect(section.leftHandSide, isNotNull);
     expect(section.operator, isNotNull);
     Expression rhs = section.rightHandSide;
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is IntegerLiteral, IntegerLiteral, rhs);
+    expect(rhs, isIntegerLiteral);
   }
 
   void test_parseCascadeSection_p_builtIn() {
@@ -6188,7 +6101,7 @@
     expect(expression, isNotNull);
     assertNoErrors();
     var section = expression as FunctionExpressionInvocation;
-    expect(section.function, new TypeMatcher<MethodInvocation>());
+    expect(section.function, isMethodInvocation);
     expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
@@ -6199,7 +6112,7 @@
     expect(expression, isNotNull);
     assertNoErrors();
     var section = expression as FunctionExpressionInvocation;
-    expect(section.function, new TypeMatcher<MethodInvocation>());
+    expect(section.function, isMethodInvocation);
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
@@ -6210,7 +6123,7 @@
     expect(expression, isNotNull);
     assertNoErrors();
     var section = expression as FunctionExpressionInvocation;
-    expect(section.function, new TypeMatcher<MethodInvocation>());
+    expect(section.function, isMethodInvocation);
     expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
@@ -6222,7 +6135,7 @@
     expect(expression, isNotNull);
     assertNoErrors();
     var section = expression as FunctionExpressionInvocation;
-    expect(section.function, new TypeMatcher<MethodInvocation>());
+    expect(section.function, isMethodInvocation);
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
@@ -6263,7 +6176,7 @@
     Expression expression = parseConstExpression('const A()');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new TypeMatcher<InstanceCreationExpression>());
+    expect(expression, isInstanceCreationExpression);
     InstanceCreationExpression instanceCreation = expression;
     expect(instanceCreation.keyword, isNotNull);
     ConstructorName name = instanceCreation.constructorName;
@@ -6345,7 +6258,7 @@
     BinaryExpression expression = parseEqualityExpression('super == y');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression.leftOperand, new TypeMatcher<SuperExpression>());
+    expect(expression.leftOperand, isSuperExpression);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.EQ_EQ);
     expect(expression.rightOperand, isNotNull);
@@ -6432,7 +6345,7 @@
   void test_parseExpression_invokeFunctionExpression() {
     Expression expression = parseExpression('(a) {return a + a;} (3)');
     var invocation = expression as FunctionExpressionInvocation;
-    expect(invocation.function, new TypeMatcher<FunctionExpression>());
+    expect(invocation.function, isFunctionExpression);
     FunctionExpression functionExpression =
         invocation.function as FunctionExpression;
     expect(functionExpression.parameters, isNotNull);
@@ -6523,7 +6436,7 @@
     Expression expression = parseExpression('super.b.c<D>()');
     MethodInvocation invocation = expression as MethodInvocation;
     Expression target = invocation.target;
-    expect(target, new TypeMatcher<PropertyAccess>());
+    expect(target, isPropertyAccess);
     expect(invocation.methodName, isNotNull);
     expect(invocation.methodName.name, 'c');
     expect(invocation.typeArguments, isNotNull);
@@ -7032,7 +6945,7 @@
     expect(expression, isNotNull);
     assertNoErrors();
     var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, new TypeMatcher<SuperExpression>());
+    expect(binaryExpression.leftOperand, isSuperExpression);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.STAR);
     expect(binaryExpression.rightOperand, isNotNull);
@@ -7295,7 +7208,7 @@
     Expression expression = parsePrimaryExpression('null');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new TypeMatcher<NullLiteral>());
+    expect(expression, isNullLiteral);
     NullLiteral literal = expression;
     expect(literal.literal, isNotNull);
   }
@@ -7406,7 +7319,7 @@
     var asExpression = expression as AsExpression;
     expect(asExpression.expression, isNotNull);
     expect(asExpression.asOperator, isNotNull);
-    expect(asExpression.type, new TypeMatcher<GenericFunctionType>());
+    expect(asExpression.type, isGenericFunctionType);
   }
 
   void test_parseRelationalExpression_as_functionType_returnType() {
@@ -7417,7 +7330,7 @@
     var asExpression = expression as AsExpression;
     expect(asExpression.expression, isNotNull);
     expect(asExpression.asOperator, isNotNull);
-    expect(asExpression.type, new TypeMatcher<GenericFunctionType>());
+    expect(asExpression.type, isGenericFunctionType);
   }
 
   void test_parseRelationalExpression_as_generic() {
@@ -7427,7 +7340,7 @@
     var asExpression = expression as AsExpression;
     expect(asExpression.expression, isNotNull);
     expect(asExpression.asOperator, isNotNull);
-    expect(asExpression.type, new TypeMatcher<TypeName>());
+    expect(asExpression.type, isTypeName);
   }
 
   void test_parseRelationalExpression_as_simple() {
@@ -7437,7 +7350,7 @@
     var asExpression = expression as AsExpression;
     expect(asExpression.expression, isNotNull);
     expect(asExpression.asOperator, isNotNull);
-    expect(asExpression.type, new TypeMatcher<TypeName>());
+    expect(asExpression.type, isTypeName);
   }
 
   void test_parseRelationalExpression_as_simple_function() {
@@ -7447,7 +7360,7 @@
     var asExpression = expression as AsExpression;
     expect(asExpression.expression, isNotNull);
     expect(asExpression.asOperator, isNotNull);
-    expect(asExpression.type, new TypeMatcher<TypeName>());
+    expect(asExpression.type, isTypeName);
   }
 
   void test_parseRelationalExpression_is() {
@@ -7575,16 +7488,15 @@
     assertNoErrors();
     var interpolation = expression as StringInterpolation;
     expect(interpolation.elements, hasLength(3));
-    expect(interpolation.elements[0], new TypeMatcher<InterpolationString>());
+    expect(interpolation.elements[0], isInterpolationString);
     InterpolationString element0 = interpolation.elements[0];
     expect(element0.value, 'x');
-    expect(
-        interpolation.elements[1], new TypeMatcher<InterpolationExpression>());
+    expect(interpolation.elements[1], isInterpolationExpression);
     InterpolationExpression element1 = interpolation.elements[1];
     expect(element1.leftBracket.lexeme, '\$');
-    expect(element1.expression, new TypeMatcher<SimpleIdentifier>());
+    expect(element1.expression, isSimpleIdentifier);
     expect(element1.rightBracket, isNull);
-    expect(interpolation.elements[2], new TypeMatcher<InterpolationString>());
+    expect(interpolation.elements[2], isInterpolationString);
     InterpolationString element2 = interpolation.elements[2];
     expect(element2.value, '');
   }
@@ -7593,7 +7505,7 @@
     Expression expression = parseStringLiteral("'a \${b} c \$this d'");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new TypeMatcher<StringInterpolation>());
+    expect(expression, isStringInterpolation);
     StringInterpolation literal = expression;
     NodeList<InterpolationElement> elements = literal.elements;
     expect(elements, hasLength(5));
@@ -7623,14 +7535,13 @@
     assertNoErrors();
     var interpolation = expression as StringInterpolation;
     expect(interpolation.elements, hasLength(3));
-    expect(interpolation.elements[0], new TypeMatcher<InterpolationString>());
+    expect(interpolation.elements[0], isInterpolationString);
     InterpolationString element0 = interpolation.elements[0];
     expect(element0.value, 'x');
-    expect(
-        interpolation.elements[1], new TypeMatcher<InterpolationExpression>());
+    expect(interpolation.elements[1], isInterpolationExpression);
     InterpolationExpression element1 = interpolation.elements[1];
-    expect(element1.expression, new TypeMatcher<SimpleIdentifier>());
-    expect(interpolation.elements[2], new TypeMatcher<InterpolationString>());
+    expect(element1.expression, isSimpleIdentifier);
+    expect(interpolation.elements[2], isInterpolationString);
     InterpolationString element2 = interpolation.elements[2];
     expect(element2.value, '');
   }
@@ -7713,14 +7624,13 @@
     assertNoErrors();
     var interpolation = expression as StringInterpolation;
     expect(interpolation.elements, hasLength(3));
-    expect(interpolation.elements[0], new TypeMatcher<InterpolationString>());
+    expect(interpolation.elements[0], isInterpolationString);
     InterpolationString element0 = interpolation.elements[0];
     expect(element0.value, '');
-    expect(
-        interpolation.elements[1], new TypeMatcher<InterpolationExpression>());
+    expect(interpolation.elements[1], isInterpolationExpression);
     InterpolationExpression element1 = interpolation.elements[1];
-    expect(element1.expression, new TypeMatcher<SimpleIdentifier>());
-    expect(interpolation.elements[2], new TypeMatcher<InterpolationString>());
+    expect(element1.expression, isSimpleIdentifier);
+    expect(interpolation.elements[2], isInterpolationString);
     InterpolationString element2 = interpolation.elements[2];
     expect(element2.value, "'y");
   }
@@ -7731,14 +7641,13 @@
     assertNoErrors();
     var interpolation = expression as StringInterpolation;
     expect(interpolation.elements, hasLength(3));
-    expect(interpolation.elements[0], new TypeMatcher<InterpolationString>());
+    expect(interpolation.elements[0], isInterpolationString);
     InterpolationString element0 = interpolation.elements[0];
     expect(element0.value, '');
-    expect(
-        interpolation.elements[1], new TypeMatcher<InterpolationExpression>());
+    expect(interpolation.elements[1], isInterpolationExpression);
     InterpolationExpression element1 = interpolation.elements[1];
-    expect(element1.expression, new TypeMatcher<SimpleIdentifier>());
-    expect(interpolation.elements[2], new TypeMatcher<InterpolationString>());
+    expect(element1.expression, isSimpleIdentifier);
+    expect(interpolation.elements[2], isInterpolationString);
     InterpolationString element2 = interpolation.elements[2];
     expect(element2.value, 'y');
   }
@@ -7776,14 +7685,13 @@
     assertNoErrors();
     var interpolation = expression as StringInterpolation;
     expect(interpolation.elements, hasLength(3));
-    expect(interpolation.elements[0], new TypeMatcher<InterpolationString>());
+    expect(interpolation.elements[0], isInterpolationString);
     InterpolationString element0 = interpolation.elements[0];
     expect(element0.value, '');
-    expect(
-        interpolation.elements[1], new TypeMatcher<InterpolationExpression>());
+    expect(interpolation.elements[1], isInterpolationExpression);
     InterpolationExpression element1 = interpolation.elements[1];
-    expect(element1.expression, new TypeMatcher<SimpleIdentifier>());
-    expect(interpolation.elements[2], new TypeMatcher<InterpolationString>());
+    expect(element1.expression, isSimpleIdentifier);
+    expect(interpolation.elements[2], isInterpolationString);
     InterpolationString element2 = interpolation.elements[2];
     expect(element2.value, '"');
   }
@@ -7803,14 +7711,13 @@
     assertNoErrors();
     var interpolation = expression as StringInterpolation;
     expect(interpolation.elements, hasLength(3));
-    expect(interpolation.elements[0], new TypeMatcher<InterpolationString>());
+    expect(interpolation.elements[0], isInterpolationString);
     InterpolationString element0 = interpolation.elements[0];
     expect(element0.value, '');
-    expect(
-        interpolation.elements[1], new TypeMatcher<InterpolationExpression>());
+    expect(interpolation.elements[1], isInterpolationExpression);
     InterpolationExpression element1 = interpolation.elements[1];
-    expect(element1.expression, new TypeMatcher<SimpleIdentifier>());
-    expect(interpolation.elements[2], new TypeMatcher<InterpolationString>());
+    expect(element1.expression, isSimpleIdentifier);
+    expect(interpolation.elements[2], isInterpolationString);
     InterpolationString element2 = interpolation.elements[2];
     expect(element2.value, 'y');
   }
@@ -8090,7 +7997,7 @@
         parseFormalParameter('covariant final a : null', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<DefaultFormalParameter>());
+    expect(parameter, isDefaultFormalParameter);
     DefaultFormalParameter defaultParameter = parameter;
     SimpleFormalParameter simpleParameter =
         defaultParameter.parameter as SimpleFormalParameter;
@@ -8109,7 +8016,7 @@
     FormalParameter parameter = parseFormalParameter('covariant final a', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<SimpleFormalParameter>());
+    expect(parameter, isSimpleFormalParameter);
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.covariantKeyword, isNotNull);
     expect(simpleParameter.identifier, isNotNull);
@@ -8124,7 +8031,7 @@
         parseFormalParameter('covariant final a = null', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<DefaultFormalParameter>());
+    expect(parameter, isDefaultFormalParameter);
     DefaultFormalParameter defaultParameter = parameter;
     SimpleFormalParameter simpleParameter =
         defaultParameter.parameter as SimpleFormalParameter;
@@ -8144,7 +8051,7 @@
         parseFormalParameter('covariant final A a : null', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<DefaultFormalParameter>());
+    expect(parameter, isDefaultFormalParameter);
     DefaultFormalParameter defaultParameter = parameter;
     SimpleFormalParameter simpleParameter =
         defaultParameter.parameter as SimpleFormalParameter;
@@ -8164,7 +8071,7 @@
         parseFormalParameter('covariant final A a', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<SimpleFormalParameter>());
+    expect(parameter, isSimpleFormalParameter);
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.covariantKeyword, isNotNull);
     expect(simpleParameter.identifier, isNotNull);
@@ -8179,7 +8086,7 @@
         parseFormalParameter('covariant final A a = null', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<DefaultFormalParameter>());
+    expect(parameter, isDefaultFormalParameter);
     DefaultFormalParameter defaultParameter = parameter;
     SimpleFormalParameter simpleParameter =
         defaultParameter.parameter as SimpleFormalParameter;
@@ -8199,12 +8106,12 @@
         parseFormalParameter('covariant String Function(int) a', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<SimpleFormalParameter>());
+    expect(parameter, isSimpleFormalParameter);
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.covariantKeyword, isNotNull);
     expect(simpleParameter.identifier, isNotNull);
     expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, new TypeMatcher<GenericFunctionType>());
+    expect(simpleParameter.type, isGenericFunctionType);
     expect(simpleParameter.isRequired, isTrue);
   }
 
@@ -8214,7 +8121,7 @@
         parseFormalParameter('covariant A a : null', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<DefaultFormalParameter>());
+    expect(parameter, isDefaultFormalParameter);
     DefaultFormalParameter defaultParameter = parameter;
     SimpleFormalParameter simpleParameter =
         defaultParameter.parameter as SimpleFormalParameter;
@@ -8234,7 +8141,7 @@
         parseFormalParameter('covariant A<B<C>> a', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<SimpleFormalParameter>());
+    expect(parameter, isSimpleFormalParameter);
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.covariantKeyword, isNotNull);
     expect(simpleParameter.identifier, isNotNull);
@@ -8249,7 +8156,7 @@
         parseFormalParameter('covariant A a = null', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<DefaultFormalParameter>());
+    expect(parameter, isDefaultFormalParameter);
     DefaultFormalParameter defaultParameter = parameter;
     SimpleFormalParameter simpleParameter =
         defaultParameter.parameter as SimpleFormalParameter;
@@ -8269,7 +8176,7 @@
         parseFormalParameter('covariant var a : null', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<DefaultFormalParameter>());
+    expect(parameter, isDefaultFormalParameter);
     DefaultFormalParameter defaultParameter = parameter;
     SimpleFormalParameter simpleParameter =
         defaultParameter.parameter as SimpleFormalParameter;
@@ -8288,7 +8195,7 @@
     FormalParameter parameter = parseFormalParameter('covariant var a', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<SimpleFormalParameter>());
+    expect(parameter, isSimpleFormalParameter);
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.covariantKeyword, isNotNull);
     expect(simpleParameter.identifier, isNotNull);
@@ -8303,7 +8210,7 @@
         parseFormalParameter('covariant var a = null', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<DefaultFormalParameter>());
+    expect(parameter, isDefaultFormalParameter);
     DefaultFormalParameter defaultParameter = parameter;
     SimpleFormalParameter simpleParameter =
         defaultParameter.parameter as SimpleFormalParameter;
@@ -8322,7 +8229,7 @@
     FormalParameter parameter = parseFormalParameter('final a : null', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<DefaultFormalParameter>());
+    expect(parameter, isDefaultFormalParameter);
     DefaultFormalParameter defaultParameter = parameter;
     SimpleFormalParameter simpleParameter =
         defaultParameter.parameter as SimpleFormalParameter;
@@ -8341,7 +8248,7 @@
     FormalParameter parameter = parseFormalParameter('final a', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<SimpleFormalParameter>());
+    expect(parameter, isSimpleFormalParameter);
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.covariantKeyword, isNull);
     expect(simpleParameter.identifier, isNotNull);
@@ -8355,7 +8262,7 @@
     FormalParameter parameter = parseFormalParameter('final a = null', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<DefaultFormalParameter>());
+    expect(parameter, isDefaultFormalParameter);
     DefaultFormalParameter defaultParameter = parameter;
     SimpleFormalParameter simpleParameter =
         defaultParameter.parameter as SimpleFormalParameter;
@@ -8374,7 +8281,7 @@
     FormalParameter parameter = parseFormalParameter('final A a : null', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<DefaultFormalParameter>());
+    expect(parameter, isDefaultFormalParameter);
     DefaultFormalParameter defaultParameter = parameter;
     SimpleFormalParameter simpleParameter =
         defaultParameter.parameter as SimpleFormalParameter;
@@ -8393,7 +8300,7 @@
     FormalParameter parameter = parseFormalParameter('final A a', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<SimpleFormalParameter>());
+    expect(parameter, isSimpleFormalParameter);
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.covariantKeyword, isNull);
     expect(simpleParameter.identifier, isNotNull);
@@ -8407,7 +8314,7 @@
     FormalParameter parameter = parseFormalParameter('final A a = null', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<DefaultFormalParameter>());
+    expect(parameter, isDefaultFormalParameter);
     DefaultFormalParameter defaultParameter = parameter;
     SimpleFormalParameter simpleParameter =
         defaultParameter.parameter as SimpleFormalParameter;
@@ -8427,12 +8334,12 @@
         parseFormalParameter('String Function(int) a', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<SimpleFormalParameter>());
+    expect(parameter, isSimpleFormalParameter);
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.covariantKeyword, isNull);
     expect(simpleParameter.identifier, isNotNull);
     expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, new TypeMatcher<GenericFunctionType>());
+    expect(simpleParameter.type, isGenericFunctionType);
     expect(simpleParameter.isRequired, isTrue);
   }
 
@@ -8441,7 +8348,7 @@
     FormalParameter parameter = parseFormalParameter('A a : null', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<DefaultFormalParameter>());
+    expect(parameter, isDefaultFormalParameter);
     DefaultFormalParameter defaultParameter = parameter;
     SimpleFormalParameter simpleParameter =
         defaultParameter.parameter as SimpleFormalParameter;
@@ -8460,7 +8367,7 @@
     FormalParameter parameter = parseFormalParameter('A a', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<DefaultFormalParameter>());
+    expect(parameter, isDefaultFormalParameter);
     DefaultFormalParameter defaultParameter = parameter;
     SimpleFormalParameter simpleParameter =
         defaultParameter.parameter as SimpleFormalParameter;
@@ -8479,7 +8386,7 @@
     FormalParameter parameter = parseFormalParameter('A a', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<SimpleFormalParameter>());
+    expect(parameter, isSimpleFormalParameter);
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.covariantKeyword, isNull);
     expect(simpleParameter.identifier, isNotNull);
@@ -8493,7 +8400,7 @@
     FormalParameter parameter = parseFormalParameter('A a = null', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<DefaultFormalParameter>());
+    expect(parameter, isDefaultFormalParameter);
     DefaultFormalParameter defaultParameter = parameter;
     SimpleFormalParameter simpleParameter =
         defaultParameter.parameter as SimpleFormalParameter;
@@ -8512,7 +8419,7 @@
     FormalParameter parameter = parseFormalParameter('A a', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<DefaultFormalParameter>());
+    expect(parameter, isDefaultFormalParameter);
     DefaultFormalParameter defaultParameter = parameter;
     SimpleFormalParameter simpleParameter =
         defaultParameter.parameter as SimpleFormalParameter;
@@ -8531,7 +8438,7 @@
     FormalParameter parameter = parseFormalParameter('var a : null', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<DefaultFormalParameter>());
+    expect(parameter, isDefaultFormalParameter);
     DefaultFormalParameter defaultParameter = parameter;
     SimpleFormalParameter simpleParameter =
         defaultParameter.parameter as SimpleFormalParameter;
@@ -8550,7 +8457,7 @@
     FormalParameter parameter = parseFormalParameter('var a', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<SimpleFormalParameter>());
+    expect(parameter, isSimpleFormalParameter);
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.covariantKeyword, isNull);
     expect(simpleParameter.identifier, isNotNull);
@@ -8564,7 +8471,7 @@
     FormalParameter parameter = parseFormalParameter('var a = null', kind);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<DefaultFormalParameter>());
+    expect(parameter, isDefaultFormalParameter);
     DefaultFormalParameter defaultParameter = parameter;
     SimpleFormalParameter simpleParameter =
         defaultParameter.parameter as SimpleFormalParameter;
@@ -8657,18 +8564,18 @@
     NodeList<FormalParameter> parameters = list.parameters;
     expect(parameters, hasLength(2));
 
-    expect(parameters[0], new TypeMatcher<SimpleFormalParameter>());
+    expect(parameters[0], isSimpleFormalParameter);
     SimpleFormalParameter required = parameters[0];
     expect(required.identifier, isNull);
-    expect(required.type, new TypeMatcher<TypeName>());
+    expect(required.type, isTypeName);
     expect((required.type as TypeName).name.name, 'A');
 
-    expect(parameters[1], new TypeMatcher<DefaultFormalParameter>());
+    expect(parameters[1], isDefaultFormalParameter);
     DefaultFormalParameter named = parameters[1];
     expect(named.identifier, isNotNull);
-    expect(named.parameter, new TypeMatcher<SimpleFormalParameter>());
+    expect(named.parameter, isSimpleFormalParameter);
     SimpleFormalParameter simple = named.parameter;
-    expect(simple.type, new TypeMatcher<TypeName>());
+    expect(simple.type, isTypeName);
     expect((simple.type as TypeName).name.name, 'B');
   }
 
@@ -8832,7 +8739,7 @@
         errorCodes:
             usingFastaParser ? [ParserErrorCode.EXTRANEOUS_MODIFIER] : []);
     expect(parameter, isNotNull);
-    expect(parameter, new TypeMatcher<FieldFormalParameter>());
+    expect(parameter, isFieldFormalParameter);
     FieldFormalParameter fieldParameter = parameter;
     expect(fieldParameter.keyword, isNotNull);
     expect(fieldParameter.type, isNull);
@@ -8846,7 +8753,7 @@
         errorCodes:
             usingFastaParser ? [ParserErrorCode.EXTRANEOUS_MODIFIER] : []);
     expect(parameter, isNotNull);
-    expect(parameter, new TypeMatcher<FieldFormalParameter>());
+    expect(parameter, isFieldFormalParameter);
     FieldFormalParameter fieldParameter = parameter;
     expect(fieldParameter.keyword, isNotNull);
     expect(fieldParameter.type, isNotNull);
@@ -8859,7 +8766,7 @@
         parseNormalFormalParameter('final this.a');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<FieldFormalParameter>());
+    expect(parameter, isFieldFormalParameter);
     FieldFormalParameter fieldParameter = parameter;
     expect(fieldParameter.keyword, isNotNull);
     expect(fieldParameter.type, isNull);
@@ -8872,7 +8779,7 @@
         parseNormalFormalParameter('final A this.a');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<FieldFormalParameter>());
+    expect(parameter, isFieldFormalParameter);
     FieldFormalParameter fieldParameter = parameter;
     expect(fieldParameter.keyword, isNotNull);
     expect(fieldParameter.type, isNotNull);
@@ -8884,7 +8791,7 @@
     NormalFormalParameter parameter = parseNormalFormalParameter('this.a(B b)');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<FieldFormalParameter>());
+    expect(parameter, isFieldFormalParameter);
     FieldFormalParameter fieldParameter = parameter;
     expect(fieldParameter.keyword, isNull);
     expect(fieldParameter.type, isNull);
@@ -8898,7 +8805,7 @@
     NormalFormalParameter parameter = parseNormalFormalParameter('this.a()');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<FieldFormalParameter>());
+    expect(parameter, isFieldFormalParameter);
     FieldFormalParameter fieldParameter = parameter;
     expect(fieldParameter.keyword, isNull);
     expect(fieldParameter.type, isNull);
@@ -8917,7 +8824,7 @@
     NormalFormalParameter parameter = parseNormalFormalParameter('this.a');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<FieldFormalParameter>());
+    expect(parameter, isFieldFormalParameter);
     FieldFormalParameter fieldParameter = parameter;
     expect(fieldParameter.keyword, isNull);
     expect(fieldParameter.type, isNull);
@@ -8929,7 +8836,7 @@
     NormalFormalParameter parameter = parseNormalFormalParameter('A this.a');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<FieldFormalParameter>());
+    expect(parameter, isFieldFormalParameter);
     FieldFormalParameter fieldParameter = parameter;
     expect(fieldParameter.keyword, isNull);
     expect(fieldParameter.type, isNotNull);
@@ -8941,7 +8848,7 @@
     NormalFormalParameter parameter = parseNormalFormalParameter('var this.a');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<FieldFormalParameter>());
+    expect(parameter, isFieldFormalParameter);
     FieldFormalParameter fieldParameter = parameter;
     expect(fieldParameter.keyword, isNotNull);
     expect(fieldParameter.type, isNull);
@@ -8975,7 +8882,7 @@
     NormalFormalParameter parameter = parseNormalFormalParameter('a()');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<FunctionTypedFormalParameter>());
+    expect(parameter, isFunctionTypedFormalParameter);
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.returnType, isNull);
     expect(functionParameter.identifier, isNotNull);
@@ -8988,7 +8895,7 @@
         parseNormalFormalParameter('covariant a()');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<FunctionTypedFormalParameter>());
+    expect(parameter, isFunctionTypedFormalParameter);
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.covariantKeyword, isNotNull);
     expect(functionParameter.returnType, isNull);
@@ -9001,7 +8908,7 @@
     NormalFormalParameter parameter = parseNormalFormalParameter('a<E>()');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<FunctionTypedFormalParameter>());
+    expect(parameter, isFunctionTypedFormalParameter);
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.returnType, isNull);
     expect(functionParameter.identifier, isNotNull);
@@ -9013,7 +8920,7 @@
     NormalFormalParameter parameter = parseNormalFormalParameter('A a()');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<FunctionTypedFormalParameter>());
+    expect(parameter, isFunctionTypedFormalParameter);
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.returnType, isNotNull);
     expect(functionParameter.identifier, isNotNull);
@@ -9025,7 +8932,7 @@
     NormalFormalParameter parameter = parseNormalFormalParameter('A a<E>()');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<FunctionTypedFormalParameter>());
+    expect(parameter, isFunctionTypedFormalParameter);
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.returnType, isNotNull);
     expect(functionParameter.identifier, isNotNull);
@@ -9038,7 +8945,7 @@
         parseNormalFormalParameter('covariant void a()');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<FunctionTypedFormalParameter>());
+    expect(parameter, isFunctionTypedFormalParameter);
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.covariantKeyword, isNotNull);
     expect(functionParameter.returnType, isNotNull);
@@ -9051,7 +8958,7 @@
     NormalFormalParameter parameter = parseNormalFormalParameter('void a()');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<FunctionTypedFormalParameter>());
+    expect(parameter, isFunctionTypedFormalParameter);
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.returnType, isNotNull);
     expect(functionParameter.identifier, isNotNull);
@@ -9063,7 +8970,7 @@
     NormalFormalParameter parameter = parseNormalFormalParameter('void a<E>()');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<FunctionTypedFormalParameter>());
+    expect(parameter, isFunctionTypedFormalParameter);
     FunctionTypedFormalParameter functionParameter = parameter;
     expect(functionParameter.returnType, isNotNull);
     expect(functionParameter.identifier, isNotNull);
@@ -9082,7 +8989,7 @@
         errorCodes:
             usingFastaParser ? [ParserErrorCode.EXTRANEOUS_MODIFIER] : []);
     expect(parameter, isNotNull);
-    expect(parameter, new TypeMatcher<SimpleFormalParameter>());
+    expect(parameter, isSimpleFormalParameter);
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.keyword, isNotNull);
     expect(simpleParameter.type, isNull);
@@ -9094,7 +9001,7 @@
         errorCodes:
             usingFastaParser ? [ParserErrorCode.EXTRANEOUS_MODIFIER] : []);
     expect(parameter, isNotNull);
-    expect(parameter, new TypeMatcher<SimpleFormalParameter>());
+    expect(parameter, isSimpleFormalParameter);
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.keyword, isNotNull);
     expect(simpleParameter.type, isNotNull);
@@ -9105,7 +9012,7 @@
     NormalFormalParameter parameter = parseNormalFormalParameter('final a');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<SimpleFormalParameter>());
+    expect(parameter, isSimpleFormalParameter);
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.keyword, isNotNull);
     expect(simpleParameter.type, isNull);
@@ -9116,7 +9023,7 @@
     NormalFormalParameter parameter = parseNormalFormalParameter('final A a');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<SimpleFormalParameter>());
+    expect(parameter, isSimpleFormalParameter);
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.keyword, isNotNull);
     expect(simpleParameter.type, isNotNull);
@@ -9128,7 +9035,7 @@
         parseNormalFormalParameter('a', inFunctionType: true);
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<SimpleFormalParameter>());
+    expect(parameter, isSimpleFormalParameter);
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.keyword, isNull);
     expect(simpleParameter.type, isNotNull);
@@ -9139,7 +9046,7 @@
     NormalFormalParameter parameter = parseNormalFormalParameter('a');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<SimpleFormalParameter>());
+    expect(parameter, isSimpleFormalParameter);
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.keyword, isNull);
     expect(simpleParameter.type, isNull);
@@ -9150,7 +9057,7 @@
     NormalFormalParameter parameter = parseNormalFormalParameter('covariant');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<SimpleFormalParameter>());
+    expect(parameter, isSimpleFormalParameter);
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.covariantKeyword, isNull);
     expect(simpleParameter.keyword, isNull);
@@ -9162,7 +9069,7 @@
     NormalFormalParameter parameter = parseNormalFormalParameter('A a');
     expect(parameter, isNotNull);
     assertNoErrors();
-    expect(parameter, new TypeMatcher<SimpleFormalParameter>());
+    expect(parameter, isSimpleFormalParameter);
     SimpleFormalParameter simpleParameter = parameter;
     expect(simpleParameter.keyword, isNull);
     expect(simpleParameter.type, isNotNull);
@@ -9986,8 +9893,7 @@
   void test_additiveExpression_missing_LHS() {
     BinaryExpression expression =
         parseExpression("+ y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftOperand);
+    expect(expression.leftOperand, isSimpleIdentifier);
     expect(expression.leftOperand.isSynthetic, isTrue);
   }
 
@@ -9996,27 +9902,23 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftOperand);
+    expect(expression.leftOperand, isSimpleIdentifier);
     expect(expression.leftOperand.isSynthetic, isTrue);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
   void test_additiveExpression_missing_RHS() {
     BinaryExpression expression =
         parseExpression("x +", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
   void test_additiveExpression_missing_RHS_super() {
     BinaryExpression expression =
         parseExpression("super +", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
@@ -10026,8 +9928,7 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_additiveExpression_precedence_multiplicative_right() {
@@ -10036,8 +9937,7 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.rightOperand);
+    expect(expression.rightOperand, isBinaryExpression);
   }
 
   void test_additiveExpression_super() {
@@ -10045,15 +9945,14 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_assignableSelector() {
     IndexExpression expression =
         parseExpression("a.b[]", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
     Expression index = expression.index;
-    expect(index, new TypeMatcher<SimpleIdentifier>());
+    expect(index, isSimpleIdentifier);
     expect(index.isSynthetic, isTrue);
   }
 
@@ -10061,8 +9960,7 @@
     AssignmentExpression expression =
         parseExpression("= y = 0", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
     Expression syntheticExpression = expression.leftHandSide;
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, syntheticExpression);
+    expect(syntheticExpression, isSimpleIdentifier);
     expect(syntheticExpression.isSynthetic, isTrue);
   }
 
@@ -10071,8 +9969,7 @@
         parseExpression("x = = 0", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
     Expression syntheticExpression =
         (expression.rightHandSide as AssignmentExpression).leftHandSide;
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, syntheticExpression);
+    expect(syntheticExpression, isSimpleIdentifier);
     expect(syntheticExpression.isSynthetic, isTrue);
   }
 
@@ -10081,32 +9978,28 @@
         parseExpression("x = y =", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
     Expression syntheticExpression =
         (expression.rightHandSide as AssignmentExpression).rightHandSide;
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, syntheticExpression);
+    expect(syntheticExpression, isSimpleIdentifier);
     expect(syntheticExpression.isSynthetic, isTrue);
   }
 
   void test_assignmentExpression_missing_LHS() {
     AssignmentExpression expression =
         parseExpression("= 0", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftHandSide);
+    expect(expression.leftHandSide, isSimpleIdentifier);
     expect(expression.leftHandSide.isSynthetic, isTrue);
   }
 
   void test_assignmentExpression_missing_RHS() {
     AssignmentExpression expression =
         parseExpression("x =", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftHandSide);
+    expect(expression.leftHandSide, isSimpleIdentifier);
     expect(expression.rightHandSide.isSynthetic, isTrue);
   }
 
   void test_bitwiseAndExpression_missing_LHS() {
     BinaryExpression expression =
         parseExpression("& y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftOperand);
+    expect(expression.leftOperand, isSimpleIdentifier);
     expect(expression.leftOperand.isSynthetic, isTrue);
   }
 
@@ -10115,27 +10008,23 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftOperand);
+    expect(expression.leftOperand, isSimpleIdentifier);
     expect(expression.leftOperand.isSynthetic, isTrue);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
   void test_bitwiseAndExpression_missing_RHS() {
     BinaryExpression expression =
         parseExpression("x &", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
   void test_bitwiseAndExpression_missing_RHS_super() {
     BinaryExpression expression =
         parseExpression("super &", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
@@ -10145,8 +10034,7 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_bitwiseAndExpression_precedence_equality_right() {
@@ -10155,8 +10043,7 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.rightOperand);
+    expect(expression.rightOperand, isBinaryExpression);
   }
 
   void test_bitwiseAndExpression_super() {
@@ -10164,15 +10051,13 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_bitwiseOrExpression_missing_LHS() {
     BinaryExpression expression =
         parseExpression("| y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftOperand);
+    expect(expression.leftOperand, isSimpleIdentifier);
     expect(expression.leftOperand.isSynthetic, isTrue);
   }
 
@@ -10181,27 +10066,23 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftOperand);
+    expect(expression.leftOperand, isSimpleIdentifier);
     expect(expression.leftOperand.isSynthetic, isTrue);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
   void test_bitwiseOrExpression_missing_RHS() {
     BinaryExpression expression =
         parseExpression("x |", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
   void test_bitwiseOrExpression_missing_RHS_super() {
     BinaryExpression expression =
         parseExpression("super |", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
@@ -10211,8 +10092,7 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_bitwiseOrExpression_precedence_xor_right() {
@@ -10221,8 +10101,7 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.rightOperand);
+    expect(expression.rightOperand, isBinaryExpression);
   }
 
   void test_bitwiseOrExpression_super() {
@@ -10230,15 +10109,13 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_bitwiseXorExpression_missing_LHS() {
     BinaryExpression expression =
         parseExpression("^ y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftOperand);
+    expect(expression.leftOperand, isSimpleIdentifier);
     expect(expression.leftOperand.isSynthetic, isTrue);
   }
 
@@ -10247,27 +10124,23 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftOperand);
+    expect(expression.leftOperand, isSimpleIdentifier);
     expect(expression.leftOperand.isSynthetic, isTrue);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
   void test_bitwiseXorExpression_missing_RHS() {
     BinaryExpression expression =
         parseExpression("x ^", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
   void test_bitwiseXorExpression_missing_RHS_super() {
     BinaryExpression expression =
         parseExpression("super ^", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
@@ -10277,8 +10150,7 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_bitwiseXorExpression_precedence_and_right() {
@@ -10287,8 +10159,7 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.rightOperand);
+    expect(expression.rightOperand, isBinaryExpression);
   }
 
   void test_bitwiseXorExpression_super() {
@@ -10296,8 +10167,7 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_classTypeAlias_withBody() {
@@ -10343,10 +10213,9 @@
     Expression expression =
         parseExpression('x ? y :', codes: [ParserErrorCode.MISSING_IDENTIFIER]);
     expectNotNullIfNoErrors(expression);
-    expect(expression, new TypeMatcher<ConditionalExpression>());
+    expect(expression, isConditionalExpression);
     ConditionalExpression conditionalExpression = expression;
-    expect(conditionalExpression.elseExpression,
-        new TypeMatcher<SimpleIdentifier>());
+    expect(conditionalExpression.elseExpression, isSimpleIdentifier);
     expect(conditionalExpression.elseExpression.isSynthetic, isTrue);
   }
 
@@ -10354,10 +10223,9 @@
     Expression expression =
         parseExpression('x ? : z', codes: [ParserErrorCode.MISSING_IDENTIFIER]);
     expectNotNullIfNoErrors(expression);
-    expect(expression, new TypeMatcher<ConditionalExpression>());
+    expect(expression, isConditionalExpression);
     ConditionalExpression conditionalExpression = expression;
-    expect(conditionalExpression.thenExpression,
-        new TypeMatcher<SimpleIdentifier>());
+    expect(conditionalExpression.thenExpression, isSimpleIdentifier);
     expect(conditionalExpression.thenExpression.isSynthetic, isTrue);
   }
 
@@ -10387,8 +10255,7 @@
   void test_equalityExpression_missing_LHS() {
     BinaryExpression expression =
         parseExpression("== y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftOperand);
+    expect(expression.leftOperand, isSimpleIdentifier);
     expect(expression.leftOperand.isSynthetic, isTrue);
   }
 
@@ -10397,27 +10264,23 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftOperand);
+    expect(expression.leftOperand, isSimpleIdentifier);
     expect(expression.leftOperand.isSynthetic, isTrue);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
   void test_equalityExpression_missing_RHS() {
     BinaryExpression expression =
         parseExpression("x ==", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
   void test_equalityExpression_missing_RHS_super() {
     BinaryExpression expression = parseExpression("super ==",
         codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
@@ -10428,8 +10291,7 @@
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
     if (!usingFastaParser) {
-      EngineTestCase.assertInstanceOf(
-          (obj) => obj is IsExpression, IsExpression, expression.leftOperand);
+      expect(expression.leftOperand, isIsExpression);
     }
   }
 
@@ -10439,8 +10301,7 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is IsExpression, IsExpression, expression.rightOperand);
+    expect(expression.rightOperand, isIsExpression);
   }
 
   void test_equalityExpression_super() {
@@ -10449,8 +10310,7 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_equalityExpression_superRHS() {
@@ -10468,8 +10328,7 @@
 //        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 0, 1)]);
     expect(result, hasLength(4));
     Expression syntheticExpression = result[0];
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, syntheticExpression);
+    expect(syntheticExpression, isSimpleIdentifier);
     expect(syntheticExpression.isSynthetic, isTrue);
   }
 
@@ -10482,8 +10341,7 @@
 //        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 1)]);
     expect(result, hasLength(4));
     Expression syntheticExpression = result[2];
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, syntheticExpression);
+    expect(syntheticExpression, isSimpleIdentifier);
     expect(syntheticExpression.isSynthetic, isTrue);
   }
 
@@ -10501,8 +10359,7 @@
           [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 0)]);
       expect(result, hasLength(4));
       Expression syntheticExpression = result[3];
-      EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-          SimpleIdentifier, syntheticExpression);
+      expect(syntheticExpression, isSimpleIdentifier);
       expect(syntheticExpression.isSynthetic, isTrue);
     }
   }
@@ -10519,8 +10376,7 @@
     ClassDeclaration declaration = unit.declarations[0] as ClassDeclaration;
     NodeList<ClassMember> members = declaration.members;
     ClassMember fieldDecl = members[1];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FieldDeclaration, FieldDeclaration, fieldDecl);
+    expect(fieldDecl, isFieldDeclaration);
     NodeList<VariableDeclaration> vars =
         (fieldDecl as FieldDeclaration).fields.variables;
     expect(vars, hasLength(1));
@@ -10594,20 +10450,17 @@
     listener.assertErrors([
       expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 6, 1)
     ]);
-    expect(member, new TypeMatcher<ConstructorDeclaration>());
+    expect(member, isConstructorDeclaration);
     NodeList<ConstructorInitializer> initializers =
         (member as ConstructorDeclaration).initializers;
     expect(initializers, hasLength(1));
     ConstructorInitializer initializer = initializers[0];
-    expect(initializer, new TypeMatcher<ConstructorFieldInitializer>());
+    expect(initializer, isConstructorFieldInitializer);
     Expression expression =
         (initializer as ConstructorFieldInitializer).expression;
     expect(expression, isNotNull);
-    expect(
-        expression,
-        usingFastaParser
-            ? new TypeMatcher<MethodInvocation>()
-            : new TypeMatcher<ParenthesizedExpression>());
+    expect(expression,
+        usingFastaParser ? isMethodInvocation : isParenthesizedExpression);
   }
 
   void test_incomplete_constructorInitializers_this() {
@@ -10712,8 +10565,7 @@
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember member = declarations[0];
-    EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableDeclaration,
-        TopLevelVariableDeclaration, member);
+    expect(member, isTopLevelVariableDeclaration);
     NodeList<VariableDeclaration> variables =
         (member as TopLevelVariableDeclaration).variables.variables;
     expect(variables, hasLength(1));
@@ -10731,8 +10583,7 @@
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember member = declarations[0];
-    EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableDeclaration,
-        TopLevelVariableDeclaration, member);
+    expect(member, isTopLevelVariableDeclaration);
     NodeList<VariableDeclaration> variables =
         (member as TopLevelVariableDeclaration).variables.variables;
     expect(variables, hasLength(1));
@@ -10748,8 +10599,7 @@
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember member = declarations[0];
-    EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableDeclaration,
-        TopLevelVariableDeclaration, member);
+    expect(member, isTopLevelVariableDeclaration);
     NodeList<VariableDeclaration> variables =
         (member as TopLevelVariableDeclaration).variables.variables;
     expect(variables, hasLength(1));
@@ -10765,8 +10615,7 @@
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember member = declarations[0];
-    EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableDeclaration,
-        TopLevelVariableDeclaration, member);
+    expect(member, isTopLevelVariableDeclaration);
     NodeList<VariableDeclaration> variables =
         (member as TopLevelVariableDeclaration).variables.variables;
     expect(variables, hasLength(1));
@@ -10785,13 +10634,11 @@
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember unitMember = declarations[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ClassDeclaration, ClassDeclaration, unitMember);
+    expect(unitMember, isClassDeclaration);
     NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
     expect(members, hasLength(1));
     ClassMember classMember = members[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FieldDeclaration, FieldDeclaration, classMember);
+    expect(classMember, isFieldDeclaration);
     VariableDeclarationList fieldList =
         (classMember as FieldDeclaration).fields;
     expect(fieldList.keyword.keyword, Keyword.CONST);
@@ -10812,13 +10659,11 @@
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember unitMember = declarations[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ClassDeclaration, ClassDeclaration, unitMember);
+    expect(unitMember, isClassDeclaration);
     NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
     expect(members, hasLength(1));
     ClassMember classMember = members[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FieldDeclaration, FieldDeclaration, classMember);
+    expect(classMember, isFieldDeclaration);
     VariableDeclarationList fieldList =
         (classMember as FieldDeclaration).fields;
     expect(fieldList.keyword.keyword, Keyword.FINAL);
@@ -10843,13 +10688,11 @@
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember unitMember = declarations[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ClassDeclaration, ClassDeclaration, unitMember);
+    expect(unitMember, isClassDeclaration);
     NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
     expect(members, hasLength(1));
     ClassMember classMember = members[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FieldDeclaration, FieldDeclaration, classMember);
+    expect(classMember, isFieldDeclaration);
     FieldDeclaration declaration = classMember;
     expect(declaration.staticKeyword.lexeme, 'static');
     VariableDeclarationList fieldList = declaration.fields;
@@ -10868,13 +10711,11 @@
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember unitMember = declarations[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ClassDeclaration, ClassDeclaration, unitMember);
+    expect(unitMember, isClassDeclaration);
     NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
     expect(members, hasLength(1));
     ClassMember classMember = members[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FieldDeclaration, FieldDeclaration, classMember);
+    expect(classMember, isFieldDeclaration);
     FieldDeclaration declaration = classMember;
     expect(declaration.staticKeyword.lexeme, 'static');
     VariableDeclarationList fieldList = declaration.fields;
@@ -10900,13 +10741,11 @@
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember unitMember = declarations[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ClassDeclaration, ClassDeclaration, unitMember);
+    expect(unitMember, isClassDeclaration);
     NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
     expect(members, hasLength(1));
     ClassMember classMember = members[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FieldDeclaration, FieldDeclaration, classMember);
+    expect(classMember, isFieldDeclaration);
     VariableDeclarationList fieldList =
         (classMember as FieldDeclaration).fields;
     TypeName type = fieldList.type;
@@ -10933,13 +10772,11 @@
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember unitMember = declarations[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ClassDeclaration, ClassDeclaration, unitMember);
+    expect(unitMember, isClassDeclaration);
     NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
     expect(members, hasLength(1));
     ClassMember classMember = members[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FieldDeclaration, FieldDeclaration, classMember);
+    expect(classMember, isFieldDeclaration);
     VariableDeclarationList fieldList =
         (classMember as FieldDeclaration).fields;
     expect(fieldList.keyword.keyword, Keyword.VAR);
@@ -10955,7 +10792,7 @@
       expectedError(ParserErrorCode.EXPECTED_TOKEN, 12, 4),
       expectedError(ParserErrorCode.EXPECTED_TOKEN, 17, 1)
     ]);
-    expect(statement, new TypeMatcher<ForStatement>());
+    expect(statement, isForStatement);
     expect(statement.toSource(), 'for (String item; i;) {}');
     expect(statement.leftSeparator, isNotNull);
     expect(statement.leftSeparator.type, TokenType.SEMICOLON);
@@ -10967,7 +10804,7 @@
     Statement statement = parseStatement('String v }', expectedEndOffset: 9);
     listener
         .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
-    expect(statement, new TypeMatcher<VariableDeclarationStatement>());
+    expect(statement, isVariableDeclarationStatement);
     expect(statement.toSource(), 'String v;');
   }
 
@@ -10977,7 +10814,7 @@
       expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 1),
       expectedError(ParserErrorCode.EXPECTED_TOKEN, 6, 1)
     ]);
-    expect(statement, new TypeMatcher<VariableDeclarationStatement>());
+    expect(statement, isVariableDeclarationStatement);
     expect(statement.toSource(), 'final ;');
   }
 
@@ -10986,7 +10823,7 @@
         parseStatement('String v String v2;', expectedEndOffset: 9);
     listener
         .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
-    expect(statement, new TypeMatcher<VariableDeclarationStatement>());
+    expect(statement, isVariableDeclarationStatement);
     expect(statement.toSource(), 'String v;');
   }
 
@@ -10995,7 +10832,7 @@
         parseStatement('String v if (true) {}', expectedEndOffset: 9);
     listener
         .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
-    expect(statement, new TypeMatcher<VariableDeclarationStatement>());
+    expect(statement, isVariableDeclarationStatement);
     expect(statement.toSource(), 'String v;');
   }
 
@@ -11003,7 +10840,7 @@
     Statement statement = parseStatement('String v {}', expectedEndOffset: 9);
     listener
         .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
-    expect(statement, new TypeMatcher<VariableDeclarationStatement>());
+    expect(statement, isVariableDeclarationStatement);
     expect(statement.toSource(), 'String v;');
   }
 
@@ -11012,7 +10849,7 @@
         parseStatement('List<String> v {}', expectedEndOffset: 15);
     listener
         .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 13, 1)]);
-    expect(statement, new TypeMatcher<VariableDeclarationStatement>());
+    expect(statement, isVariableDeclarationStatement);
     expect(statement.toSource(), 'List<String> v;');
   }
 
@@ -11190,8 +11027,7 @@
       SimpleIdentifier simpleId = thenStatement.expression;
       expect(simpleId.isSynthetic, isTrue);
     } else {
-      EngineTestCase.assertInstanceOf((obj) => obj is EmptyStatement,
-          EmptyStatement, ifStatement.thenStatement);
+      expect(ifStatement.thenStatement, isEmptyStatement);
     }
   }
 
@@ -11289,8 +11125,7 @@
   void test_logicalAndExpression_missing_LHS() {
     BinaryExpression expression =
         parseExpression("&& y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftOperand);
+    expect(expression.leftOperand, isSimpleIdentifier);
     expect(expression.leftOperand.isSynthetic, isTrue);
   }
 
@@ -11299,19 +11134,16 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftOperand);
+    expect(expression.leftOperand, isSimpleIdentifier);
     expect(expression.leftOperand.isSynthetic, isTrue);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
   void test_logicalAndExpression_missing_RHS() {
     BinaryExpression expression =
         parseExpression("x &&", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
@@ -11321,8 +11153,7 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_logicalAndExpression_precedence_bitwiseOr_right() {
@@ -11331,15 +11162,13 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.rightOperand);
+    expect(expression.rightOperand, isBinaryExpression);
   }
 
   void test_logicalOrExpression_missing_LHS() {
     BinaryExpression expression =
         parseExpression("|| y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftOperand);
+    expect(expression.leftOperand, isSimpleIdentifier);
     expect(expression.leftOperand.isSynthetic, isTrue);
   }
 
@@ -11348,19 +11177,16 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftOperand);
+    expect(expression.leftOperand, isSimpleIdentifier);
     expect(expression.leftOperand.isSynthetic, isTrue);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
   void test_logicalOrExpression_missing_RHS() {
     BinaryExpression expression =
         parseExpression("x ||", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
@@ -11370,8 +11196,7 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_logicalOrExpression_precedence_logicalAnd_right() {
@@ -11380,8 +11205,7 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.rightOperand);
+    expect(expression.rightOperand, isBinaryExpression);
   }
 
   void test_method_missingBody() {
@@ -11423,11 +11247,9 @@
         unit.declarations[0] as ClassDeclaration;
     NodeList<ClassMember> members = classDeclaration.members;
     expect(members, hasLength(2));
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is MethodDeclaration, MethodDeclaration, members[0]);
+    expect(members[0], isMethodDeclaration);
     ClassMember member = members[1];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is MethodDeclaration, MethodDeclaration, member);
+    expect(member, isMethodDeclaration);
     expect((member as MethodDeclaration).name.name, "foo");
   }
 
@@ -11442,7 +11264,7 @@
       // existing annotation can be associated with a class member.
       expect(member, isNull);
     } else {
-      expect(member, new TypeMatcher<MethodDeclaration>());
+      expect(member, isMethodDeclaration);
       MethodDeclaration method = member;
       expect(method.documentationComment, isNull);
       NodeList<Annotation> metadata = method.metadata;
@@ -11454,7 +11276,7 @@
   void test_missingSemicolon_varialeDeclarationList() {
     void verify(CompilationUnitMember member, String expectedTypeName,
         String expectedName, String expectedSemicolon) {
-      expect(member, new TypeMatcher<TopLevelVariableDeclaration>());
+      expect(member, isTopLevelVariableDeclaration);
       TopLevelVariableDeclaration declaration = member;
       VariableDeclarationList variableList = declaration.variables;
       expect(variableList, isNotNull);
@@ -11488,8 +11310,7 @@
   void test_multiplicativeExpression_missing_LHS() {
     BinaryExpression expression =
         parseExpression("* y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftOperand);
+    expect(expression.leftOperand, isSimpleIdentifier);
     expect(expression.leftOperand.isSynthetic, isTrue);
   }
 
@@ -11498,42 +11319,36 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftOperand);
+    expect(expression.leftOperand, isSimpleIdentifier);
     expect(expression.leftOperand.isSynthetic, isTrue);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
   void test_multiplicativeExpression_missing_RHS() {
     BinaryExpression expression =
         parseExpression("x *", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
   void test_multiplicativeExpression_missing_RHS_super() {
     BinaryExpression expression =
         parseExpression("super *", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
   void test_multiplicativeExpression_precedence_unary_left() {
     BinaryExpression expression =
         parseExpression("-x *", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is PrefixExpression,
-        PrefixExpression, expression.leftOperand);
+    expect(expression.leftOperand, isPrefixExpression);
   }
 
   void test_multiplicativeExpression_precedence_unary_right() {
     BinaryExpression expression =
         parseExpression("* -y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is PrefixExpression,
-        PrefixExpression, expression.rightOperand);
+    expect(expression.rightOperand, isPrefixExpression);
   }
 
   void test_multiplicativeExpression_super() {
@@ -11542,8 +11357,7 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_namedParameterOutsideGroup() {
@@ -11582,8 +11396,7 @@
   void test_prefixExpression_missing_operand_minus() {
     PrefixExpression expression =
         parseExpression("-", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.operand);
+    expect(expression.operand, isSimpleIdentifier);
     expect(expression.operand.isSynthetic, isTrue);
     expect(expression.operator.type, TokenType.MINUS);
   }
@@ -11620,8 +11433,7 @@
   void test_relationalExpression_missing_LHS() {
     IsExpression expression =
         parseExpression("is y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.expression);
+    expect(expression.expression, isSimpleIdentifier);
     expect(expression.expression.isSynthetic, isTrue);
   }
 
@@ -11630,19 +11442,16 @@
       ParserErrorCode.EXPECTED_TYPE_NAME,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.expression);
+    expect(expression.expression, isSimpleIdentifier);
     expect(expression.expression.isSynthetic, isTrue);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is TypeName, TypeName, expression.type);
+    expect(expression.type, isTypeName);
     expect(expression.type.isSynthetic, isTrue);
   }
 
   void test_relationalExpression_missing_RHS() {
     IsExpression expression =
         parseExpression("x is", codes: [ParserErrorCode.EXPECTED_TYPE_NAME]);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is TypeName, TypeName, expression.type);
+    expect(expression.type, isTypeName);
     expect(expression.type.isSynthetic, isTrue);
   }
 
@@ -11652,15 +11461,13 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.expression);
+    expect(expression.expression, isBinaryExpression);
   }
 
   void test_shiftExpression_missing_LHS() {
     BinaryExpression expression =
         parseExpression("<< y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftOperand);
+    expect(expression.leftOperand, isSimpleIdentifier);
     expect(expression.leftOperand.isSynthetic, isTrue);
   }
 
@@ -11669,27 +11476,23 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.leftOperand);
+    expect(expression.leftOperand, isSimpleIdentifier);
     expect(expression.leftOperand.isSynthetic, isTrue);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
   void test_shiftExpression_missing_RHS() {
     BinaryExpression expression =
         parseExpression("x <<", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
   void test_shiftExpression_missing_RHS_super() {
     BinaryExpression expression = parseExpression("super <<",
         codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier,
-        SimpleIdentifier, expression.rightOperand);
+    expect(expression.rightOperand, isSimpleIdentifier);
     expect(expression.rightOperand.isSynthetic, isTrue);
   }
 
@@ -11699,8 +11502,7 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_shiftExpression_precedence_unary_right() {
@@ -11709,8 +11511,7 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.rightOperand);
+    expect(expression.rightOperand, isBinaryExpression);
   }
 
   void test_shiftExpression_super() {
@@ -11718,8 +11519,7 @@
       ParserErrorCode.MISSING_IDENTIFIER,
       ParserErrorCode.MISSING_IDENTIFIER
     ]);
-    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
-        BinaryExpression, expression.leftOperand);
+    expect(expression.leftOperand, isBinaryExpression);
   }
 
   void test_typedef_eof() {
@@ -11730,8 +11530,7 @@
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(1));
     CompilationUnitMember member = declarations[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FunctionTypeAlias, FunctionTypeAlias, member);
+    expect(member, isFunctionTypeAlias);
   }
 
   void test_unaryPlus() {
@@ -12240,7 +12039,7 @@
     FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
     expectNotNullIfNoErrors(functionBody);
     assertNoErrors();
-    expect(functionBody, new TypeMatcher<EmptyFunctionBody>());
+    expect(functionBody, isEmptyFunctionBody);
   }
 
   void test_parseFunctionBody_skip_block_invalid() {
@@ -12249,7 +12048,7 @@
     FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
     expectNotNullIfNoErrors(functionBody);
     listener.assertErrorsWithCodes([ScannerErrorCode.EXPECTED_TOKEN]);
-    expect(functionBody, new TypeMatcher<EmptyFunctionBody>());
+    expect(functionBody, isEmptyFunctionBody);
   }
 
   void test_parseFunctionBody_skip_blocks() {
@@ -12258,7 +12057,7 @@
     FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
     expectNotNullIfNoErrors(functionBody);
     assertNoErrors();
-    expect(functionBody, new TypeMatcher<EmptyFunctionBody>());
+    expect(functionBody, isEmptyFunctionBody);
   }
 
   void test_parseFunctionBody_skip_expression() {
@@ -12267,7 +12066,7 @@
     FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
     expectNotNullIfNoErrors(functionBody);
     assertNoErrors();
-    expect(functionBody, new TypeMatcher<EmptyFunctionBody>());
+    expect(functionBody, isEmptyFunctionBody);
   }
 
   void test_parseModifiers_abstract() {
@@ -12554,9 +12353,9 @@
   ConstructorName parseConstructorName(String name) {
     createParser('new $name();');
     Statement statement = parser.parseStatement2();
-    expect(statement, new TypeMatcher<ExpressionStatement>());
+    expect(statement, isExpressionStatement);
     Expression expression = (statement as ExpressionStatement).expression;
-    expect(expression, new TypeMatcher<InstanceCreationExpression>());
+    expect(expression, isInstanceCreationExpression);
     return (expression as InstanceCreationExpression).constructorName;
   }
 
@@ -12604,7 +12403,7 @@
    */
   void parseStatementList(String content, int expectedCount) {
     Statement statement = parseStatement('{$content}');
-    expect(statement, new TypeMatcher<Block>());
+    expect(statement, isBlock);
     Block block = statement;
     expect(block.statements, hasLength(expectedCount));
   }
@@ -13045,7 +12844,7 @@
     CommentReference reference = parseCommentReference('new a.b', 7);
     expectNotNullIfNoErrors(reference);
     assertNoErrors();
-    expect(reference.identifier, new TypeMatcher<PrefixedIdentifier>());
+    expect(reference.identifier, isPrefixedIdentifier);
     PrefixedIdentifier prefixedIdentifier = reference.identifier;
     SimpleIdentifier prefix = prefixedIdentifier.prefix;
     expect(prefix.token, isNotNull);
@@ -13063,7 +12862,7 @@
     CommentReference reference = parseCommentReference('new a', 5);
     expectNotNullIfNoErrors(reference);
     assertNoErrors();
-    expect(reference.identifier, new TypeMatcher<SimpleIdentifier>());
+    expect(reference.identifier, isSimpleIdentifier);
     SimpleIdentifier identifier = reference.identifier;
     expect(identifier.token, isNotNull);
     expect(identifier.name, "a");
@@ -13075,7 +12874,7 @@
     CommentReference reference = parseCommentReference('operator ==', 5);
     expectNotNullIfNoErrors(reference);
     assertNoErrors();
-    expect(reference.identifier, new TypeMatcher<SimpleIdentifier>());
+    expect(reference.identifier, isSimpleIdentifier);
     SimpleIdentifier identifier = reference.identifier;
     expect(identifier.token, isNotNull);
     expect(identifier.name, "==");
@@ -13087,7 +12886,7 @@
     CommentReference reference = parseCommentReference('Object.operator==', 7);
     expectNotNullIfNoErrors(reference);
     assertNoErrors();
-    expect(reference.identifier, new TypeMatcher<PrefixedIdentifier>());
+    expect(reference.identifier, isPrefixedIdentifier);
     PrefixedIdentifier prefixedIdentifier = reference.identifier;
     SimpleIdentifier prefix = prefixedIdentifier.prefix;
     expect(prefix.token, isNotNull);
@@ -13105,7 +12904,7 @@
     CommentReference reference = parseCommentReference('==', 5);
     expectNotNullIfNoErrors(reference);
     assertNoErrors();
-    expect(reference.identifier, new TypeMatcher<SimpleIdentifier>());
+    expect(reference.identifier, isSimpleIdentifier);
     SimpleIdentifier identifier = reference.identifier;
     expect(identifier.token, isNotNull);
     expect(identifier.name, "==");
@@ -13117,7 +12916,7 @@
     CommentReference reference = parseCommentReference('Object.==', 7);
     expectNotNullIfNoErrors(reference);
     assertNoErrors();
-    expect(reference.identifier, new TypeMatcher<PrefixedIdentifier>());
+    expect(reference.identifier, isPrefixedIdentifier);
     PrefixedIdentifier prefixedIdentifier = reference.identifier;
     SimpleIdentifier prefix = prefixedIdentifier.prefix;
     expect(prefix.token, isNotNull);
@@ -13135,7 +12934,7 @@
     CommentReference reference = parseCommentReference('a.b', 7);
     expectNotNullIfNoErrors(reference);
     assertNoErrors();
-    expect(reference.identifier, new TypeMatcher<PrefixedIdentifier>());
+    expect(reference.identifier, isPrefixedIdentifier);
     PrefixedIdentifier prefixedIdentifier = reference.identifier;
     SimpleIdentifier prefix = prefixedIdentifier.prefix;
     expect(prefix.token, isNotNull);
@@ -13153,7 +12952,7 @@
     CommentReference reference = parseCommentReference('a', 5);
     expectNotNullIfNoErrors(reference);
     assertNoErrors();
-    expect(reference.identifier, new TypeMatcher<SimpleIdentifier>());
+    expect(reference.identifier, isSimpleIdentifier);
     SimpleIdentifier identifier = reference.identifier;
     expect(identifier.token, isNotNull);
     expect(identifier.name, "a");
@@ -13165,7 +12964,7 @@
     CommentReference reference = parseCommentReference('', 5);
     expectNotNullIfNoErrors(reference);
     assertNoErrors();
-    expect(reference.identifier, new TypeMatcher<SimpleIdentifier>());
+    expect(reference.identifier, isSimpleIdentifier);
     SimpleIdentifier identifier = reference.identifier;
     expect(identifier, isNotNull);
     expect(identifier.isSynthetic, isTrue);
@@ -13186,10 +12985,7 @@
     CommentReference reference = parseCommentReference('this', 5);
     expectNotNullIfNoErrors(reference);
     assertNoErrors();
-    SimpleIdentifier identifier = EngineTestCase.assertInstanceOf(
-        (obj) => obj is SimpleIdentifier,
-        SimpleIdentifier,
-        reference.identifier);
+    SimpleIdentifier identifier = reference.identifier;
     expect(identifier.token, isNotNull);
     expect(identifier.name, "a");
     expect(identifier.offset, 5);
@@ -13720,7 +13516,7 @@
     assertNoErrors();
     expect(clause.extendsKeyword, isNotNull);
     expect(clause.superclass, isNotNull);
-    expect(clause.superclass, new TypeMatcher<TypeName>());
+    expect(clause.superclass, isTypeName);
   }
 
   void test_parseFunctionBody_block() {
@@ -13728,7 +13524,7 @@
     FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
     expectNotNullIfNoErrors(functionBody);
     assertNoErrors();
-    expect(functionBody, new TypeMatcher<BlockFunctionBody>());
+    expect(functionBody, isBlockFunctionBody);
     BlockFunctionBody body = functionBody;
     expect(body.keyword, isNull);
     expect(body.star, isNull);
@@ -13743,7 +13539,7 @@
     FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
     expectNotNullIfNoErrors(functionBody);
     assertNoErrors();
-    expect(functionBody, new TypeMatcher<BlockFunctionBody>());
+    expect(functionBody, isBlockFunctionBody);
     BlockFunctionBody body = functionBody;
     expect(body.keyword, isNotNull);
     expect(body.keyword.lexeme, Parser.ASYNC);
@@ -13759,7 +13555,7 @@
     FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
     expectNotNullIfNoErrors(functionBody);
     assertNoErrors();
-    expect(functionBody, new TypeMatcher<BlockFunctionBody>());
+    expect(functionBody, isBlockFunctionBody);
     BlockFunctionBody body = functionBody;
     expect(body.keyword, isNotNull);
     expect(body.keyword.lexeme, Parser.ASYNC);
@@ -13775,7 +13571,7 @@
     FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
     expectNotNullIfNoErrors(functionBody);
     assertNoErrors();
-    expect(functionBody, new TypeMatcher<BlockFunctionBody>());
+    expect(functionBody, isBlockFunctionBody);
     BlockFunctionBody body = functionBody;
     expect(body.keyword, isNotNull);
     expect(body.keyword.lexeme, Parser.SYNC);
@@ -13791,7 +13587,7 @@
     FunctionBody functionBody = parser.parseFunctionBody(true, null, false);
     expectNotNullIfNoErrors(functionBody);
     assertNoErrors();
-    expect(functionBody, new TypeMatcher<EmptyFunctionBody>());
+    expect(functionBody, isEmptyFunctionBody);
     EmptyFunctionBody body = functionBody;
     expect(body.semicolon, isNotNull);
   }
@@ -13801,7 +13597,7 @@
     FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
     expectNotNullIfNoErrors(functionBody);
     assertNoErrors();
-    expect(functionBody, new TypeMatcher<ExpressionFunctionBody>());
+    expect(functionBody, isExpressionFunctionBody);
     ExpressionFunctionBody body = functionBody;
     expect(body.keyword, isNull);
     expect(body.functionDefinition, isNotNull);
@@ -13817,7 +13613,7 @@
     FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
     expectNotNullIfNoErrors(functionBody);
     assertNoErrors();
-    expect(functionBody, new TypeMatcher<ExpressionFunctionBody>());
+    expect(functionBody, isExpressionFunctionBody);
     ExpressionFunctionBody body = functionBody;
     expect(body.keyword, isNotNull);
     expect(body.keyword.lexeme, Parser.ASYNC);
@@ -13897,7 +13693,7 @@
     expect(unit, isNotNull);
     FunctionDeclaration f = unit.declarations[0];
     ExpressionFunctionBody body = f.functionExpression.body;
-    expect(body.expression, new TypeMatcher<InstanceCreationExpression>());
+    expect(body.expression, isInstanceCreationExpression);
     InstanceCreationExpressionImpl creation = body.expression;
     expect(creation.keyword, isNull);
     ConstructorName constructorName = creation.constructorName;
@@ -13918,7 +13714,7 @@
     expect(unit, isNotNull);
     FunctionDeclaration f = unit.declarations[0];
     ExpressionFunctionBody body = f.functionExpression.body;
-    expect(body.expression, new TypeMatcher<InstanceCreationExpression>());
+    expect(body.expression, isInstanceCreationExpression);
     InstanceCreationExpressionImpl creation = body.expression;
     expect(creation.keyword, isNull);
     ConstructorName constructorName = creation.constructorName;
@@ -13936,7 +13732,7 @@
     expect(unit, isNotNull);
     FunctionDeclaration f = unit.declarations[0];
     ExpressionFunctionBody body = f.functionExpression.body;
-    expect(body.expression, new TypeMatcher<InstanceCreationExpression>());
+    expect(body.expression, isInstanceCreationExpression);
     InstanceCreationExpression creation = body.expression;
     expect(creation.keyword, isNull);
     ConstructorName constructorName = creation.constructorName;
@@ -14035,13 +13831,13 @@
 Function<A>(core.List<core.int> x) m() => null;
 ''');
     Statement statement = parser.parseStatement2();
-    expect(statement, new TypeMatcher<FunctionDeclarationStatement>());
+    expect(statement, isFunctionDeclarationStatement);
     expect(
         (statement as FunctionDeclarationStatement)
             .functionDeclaration
             .functionExpression
             .body,
-        new TypeMatcher<ExpressionFunctionBody>());
+        isExpressionFunctionBody);
   }
 
   void test_parseStatements_multiple() {
@@ -14078,16 +13874,16 @@
     NodeList<FormalParameter> parameters = parameterList.parameters;
     expect(parameters, hasLength(2));
 
-    expect(parameters[0], new TypeMatcher<SimpleFormalParameter>());
+    expect(parameters[0], isSimpleFormalParameter);
     SimpleFormalParameter parameter = parameters[0];
     expect(parameter.identifier, isNull);
-    expect(parameter.type, new TypeMatcher<TypeName>());
+    expect(parameter.type, isTypeName);
     expect((parameter.type as TypeName).name.name, 'int');
 
-    expect(parameters[1], new TypeMatcher<SimpleFormalParameter>());
+    expect(parameters[1], isSimpleFormalParameter);
     parameter = parameters[1];
     expect(parameter.identifier, isNull);
-    expect(parameter.type, new TypeMatcher<TypeName>());
+    expect(parameter.type, isTypeName);
     expect((parameter.type as TypeName).name.name, 'int');
   }
 
@@ -14163,18 +13959,18 @@
     NodeList<FormalParameter> parameters = parameterList.parameters;
     expect(parameters, hasLength(2));
 
-    expect(parameters[0], new TypeMatcher<SimpleFormalParameter>());
+    expect(parameters[0], isSimpleFormalParameter);
     SimpleFormalParameter parameter = parameters[0];
     expect(parameter.identifier, isNotNull);
     expect(parameter.identifier.name, 's');
-    expect(parameter.type, new TypeMatcher<TypeName>());
+    expect(parameter.type, isTypeName);
     expect((parameter.type as TypeName).name.name, 'String');
 
-    expect(parameters[1], new TypeMatcher<SimpleFormalParameter>());
+    expect(parameters[1], isSimpleFormalParameter);
     parameter = parameters[1];
     expect(parameter.identifier, isNotNull);
     expect(parameter.identifier.name, 'i');
-    expect(parameter.type, new TypeMatcher<TypeName>());
+    expect(parameter.type, isTypeName);
     expect((parameter.type as TypeName).name.name, 'int');
   }
 
@@ -14349,7 +14145,7 @@
     TypeParameter parameter = parser.parseTypeParameter();
     expectNotNullIfNoErrors(parameter);
     assertNoErrors();
-    expect(parameter.bound, new TypeMatcher<GenericFunctionType>());
+    expect(parameter.bound, isGenericFunctionType);
     expect(parameter.extendsKeyword, isNotNull);
     expect(parameter.name, isNotNull);
   }
@@ -14359,7 +14155,7 @@
     TypeParameter parameter = parser.parseTypeParameter();
     expectNotNullIfNoErrors(parameter);
     assertNoErrors();
-    expect(parameter.bound, new TypeMatcher<GenericFunctionType>());
+    expect(parameter.bound, isGenericFunctionType);
     expect(parameter.extendsKeyword, isNotNull);
     expect(parameter.name, isNotNull);
   }
@@ -14369,7 +14165,7 @@
     TypeParameter parameter = parser.parseTypeParameter();
     expectNotNullIfNoErrors(parameter);
     assertNoErrors();
-    expect(parameter.bound, new TypeMatcher<TypeName>());
+    expect(parameter.bound, isTypeName);
     expect(parameter.extendsKeyword, isNotNull);
     expect(parameter.name, isNotNull);
   }
@@ -14379,7 +14175,7 @@
     TypeParameter parameter = parser.parseTypeParameter();
     expectNotNullIfNoErrors(parameter);
     assertNoErrors();
-    expect(parameter.bound, new TypeMatcher<TypeName>());
+    expect(parameter.bound, isTypeName);
     expect(parameter.extendsKeyword, isNotNull);
     expect(parameter.name, isNotNull);
   }
@@ -15156,7 +14952,7 @@
         as FunctionDeclarationStatement;
     assertNoErrors();
     FunctionDeclaration function = statement.functionDeclaration;
-    expect(function.returnType, new TypeMatcher<GenericFunctionType>());
+    expect(function.returnType, isGenericFunctionType);
   }
 
   void test_parseNonLabeledStatement_null() {
@@ -15200,7 +14996,7 @@
     List<VariableDeclaration> variables = variableList.variables;
     expect(variables, hasLength(1));
     expect(variables[0].name.name, 'v');
-    expect(variableList.type, new TypeMatcher<GenericFunctionType>());
+    expect(variableList.type, isGenericFunctionType);
   }
 
   void
@@ -15213,7 +15009,7 @@
     List<VariableDeclaration> variables = variableList.variables;
     expect(variables, hasLength(1));
     expect(variables[0].name.name, 'v');
-    expect(variableList.type, new TypeMatcher<GenericFunctionType>());
+    expect(variableList.type, isGenericFunctionType);
   }
 
   void
@@ -15225,7 +15021,7 @@
     List<VariableDeclaration> variables = variableList.variables;
     expect(variables, hasLength(1));
     expect(variables[0].name.name, 'v');
-    expect(variableList.type, new TypeMatcher<GenericFunctionType>());
+    expect(variableList.type, isGenericFunctionType);
   }
 
   void
@@ -15237,7 +15033,7 @@
     List<VariableDeclaration> variables = variableList.variables;
     expect(variables, hasLength(1));
     expect(variables[0].name.name, 'v');
-    expect(variableList.type, new TypeMatcher<GenericFunctionType>());
+    expect(variableList.type, isGenericFunctionType);
   }
 
   void
@@ -15249,7 +15045,7 @@
     List<VariableDeclaration> variables = variableList.variables;
     expect(variables, hasLength(1));
     expect(variables[0].name.name, 'v');
-    expect(variableList.type, new TypeMatcher<GenericFunctionType>());
+    expect(variableList.type, isGenericFunctionType);
   }
 
   void test_parseNonLabeledStatement_variableDeclaration_gftType_returnType() {
@@ -15260,7 +15056,7 @@
     List<VariableDeclaration> variables = variableList.variables;
     expect(variables, hasLength(1));
     expect(variables[0].name.name, 'v');
-    expect(variableList.type, new TypeMatcher<GenericFunctionType>());
+    expect(variableList.type, isGenericFunctionType);
   }
 
   void
@@ -15272,7 +15068,7 @@
     List<VariableDeclaration> variables = variableList.variables;
     expect(variables, hasLength(1));
     expect(variables[0].name.name, 'v');
-    expect(variableList.type, new TypeMatcher<GenericFunctionType>());
+    expect(variableList.type, isGenericFunctionType);
   }
 
   void test_parseNonLabeledStatement_variableDeclaration_typeParam() {
@@ -15315,8 +15111,7 @@
     TypeName typeName = variableList.type;
     expect(typeName.name.name, 'C');
     expect(typeName.typeArguments.arguments, hasLength(1));
-    expect(typeName.typeArguments.arguments[0],
-        new TypeMatcher<GenericFunctionType>());
+    expect(typeName.typeArguments.arguments[0], isGenericFunctionType);
   }
 
   void test_parseStatement_emptyTypeArgumentList() {
@@ -15336,7 +15131,7 @@
         parseStatement('void Function<A>(core.List<core.int> x) m() => null;')
             as FunctionDeclarationStatement;
     expect(statement.functionDeclaration.functionExpression.body,
-        new TypeMatcher<ExpressionFunctionBody>());
+        isExpressionFunctionBody);
   }
 
   void test_parseStatement_functionDeclaration_noReturnType() {
@@ -15935,7 +15730,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ClassDeclaration>());
+    expect(member, isClassDeclaration);
     ClassDeclaration declaration = member;
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNotNull);
@@ -15954,7 +15749,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ClassDeclaration>());
+    expect(member, isClassDeclaration);
     ClassDeclaration declaration = member;
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
@@ -15974,7 +15769,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ClassDeclaration>());
+    expect(member, isClassDeclaration);
     ClassDeclaration declaration = member;
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
@@ -15993,7 +15788,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ClassDeclaration>());
+    expect(member, isClassDeclaration);
     ClassDeclaration declaration = member;
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
@@ -16012,7 +15807,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ClassDeclaration>());
+    expect(member, isClassDeclaration);
     ClassDeclaration declaration = member;
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
@@ -16032,7 +15827,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ClassDeclaration>());
+    expect(member, isClassDeclaration);
     ClassDeclaration declaration = member;
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
@@ -16052,7 +15847,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ClassDeclaration>());
+    expect(member, isClassDeclaration);
     ClassDeclaration declaration = member;
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
@@ -16074,7 +15869,7 @@
     {
       var annotation = declaration.metadata[0];
       expect(annotation.atSign, isNotNull);
-      expect(annotation.name, new TypeMatcher<SimpleIdentifier>());
+      expect(annotation.name, isSimpleIdentifier);
       expect(annotation.name.name, 'A');
       expect(annotation.period, isNull);
       expect(annotation.constructorName, isNull);
@@ -16084,7 +15879,7 @@
     {
       var annotation = declaration.metadata[1];
       expect(annotation.atSign, isNotNull);
-      expect(annotation.name, new TypeMatcher<SimpleIdentifier>());
+      expect(annotation.name, isSimpleIdentifier);
       expect(annotation.name.name, 'B');
       expect(annotation.period, isNull);
       expect(annotation.constructorName, isNull);
@@ -16095,7 +15890,7 @@
     {
       var annotation = declaration.metadata[2];
       expect(annotation.atSign, isNotNull);
-      expect(annotation.name, new TypeMatcher<PrefixedIdentifier>());
+      expect(annotation.name, isPrefixedIdentifier);
       expect(annotation.name.name, 'C.foo');
       expect(annotation.period, isNull);
       expect(annotation.constructorName, isNull);
@@ -16106,7 +15901,7 @@
     {
       var annotation = declaration.metadata[3];
       expect(annotation.atSign, isNotNull);
-      expect(annotation.name, new TypeMatcher<PrefixedIdentifier>());
+      expect(annotation.name, isPrefixedIdentifier);
       expect(annotation.name.name, 'd.E');
       expect(annotation.period, isNotNull);
       expect(annotation.constructorName, isNotNull);
@@ -16127,7 +15922,7 @@
     } else {
       assertNoErrors();
     }
-    expect(member, new TypeMatcher<ClassDeclaration>());
+    expect(member, isClassDeclaration);
     ClassDeclaration declaration = member;
     NativeClause nativeClause = declaration.nativeClause;
     expect(nativeClause, isNotNull);
@@ -16142,7 +15937,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ClassDeclaration>());
+    expect(member, isClassDeclaration);
     ClassDeclaration declaration = member;
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
@@ -16161,7 +15956,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ClassTypeAlias>());
+    expect(member, isClassTypeAlias);
     ClassTypeAlias typeAlias = member;
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
@@ -16179,7 +15974,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ClassTypeAlias>());
+    expect(member, isClassTypeAlias);
     ClassTypeAlias typeAlias = member;
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
@@ -16196,7 +15991,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ClassDeclaration>());
+    expect(member, isClassDeclaration);
     ClassDeclaration declaration = member;
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
@@ -16424,7 +16219,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<TopLevelVariableDeclaration>());
+    expect(member, isTopLevelVariableDeclaration);
     TopLevelVariableDeclaration declaration = member;
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
@@ -16435,7 +16230,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ClassDeclaration>());
+    expect(member, isClassDeclaration);
     ClassDeclaration declaration = member;
     expect(declaration.name.name, "A");
     expect(declaration.members, hasLength(0));
@@ -16446,7 +16241,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ClassTypeAlias>());
+    expect(member, isClassTypeAlias);
     ClassTypeAlias declaration = member;
     expect(declaration.name.name, "A");
     expect(declaration.abstractKeyword, isNotNull);
@@ -16457,7 +16252,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<TopLevelVariableDeclaration>());
+    expect(member, isTopLevelVariableDeclaration);
     TopLevelVariableDeclaration declaration = member;
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
@@ -16479,7 +16274,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<TopLevelVariableDeclaration>());
+    expect(member, isTopLevelVariableDeclaration);
     TopLevelVariableDeclaration declaration = member;
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
@@ -16491,7 +16286,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FunctionDeclaration>());
+    expect(member, isFunctionDeclaration);
     FunctionDeclaration declaration = member;
     expect(declaration.externalKeyword, isNotNull);
     expect(declaration.functionExpression, isNotNull);
@@ -16503,7 +16298,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FunctionDeclaration>());
+    expect(member, isFunctionDeclaration);
     FunctionDeclaration declaration = member;
     expect(declaration.externalKeyword, isNotNull);
     expect(declaration.functionExpression, isNotNull);
@@ -16515,7 +16310,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FunctionDeclaration>());
+    expect(member, isFunctionDeclaration);
     FunctionDeclaration declaration = member;
     expect(declaration.returnType, isNull);
     expect(declaration.functionExpression.typeParameters, isNotNull);
@@ -16527,7 +16322,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FunctionDeclaration>());
+    expect(member, isFunctionDeclaration);
     FunctionDeclaration declaration = member;
     expect(declaration.returnType, isNull);
     expect(declaration.functionExpression.typeParameters, isNotNull);
@@ -16538,7 +16333,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FunctionDeclaration>());
+    expect(member, isFunctionDeclaration);
     FunctionDeclaration declaration = member;
     expect(declaration.returnType, isNotNull);
     expect(declaration.functionExpression.typeParameters, isNotNull);
@@ -16549,7 +16344,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FunctionDeclaration>());
+    expect(member, isFunctionDeclaration);
     FunctionDeclaration declaration = member;
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNull);
@@ -16580,7 +16375,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FunctionDeclaration>());
+    expect(member, isFunctionDeclaration);
     FunctionDeclaration declaration = member;
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNull);
@@ -16591,7 +16386,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FunctionDeclaration>());
+    expect(member, isFunctionDeclaration);
     FunctionDeclaration declaration = member;
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNull);
@@ -16602,7 +16397,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FunctionDeclaration>());
+    expect(member, isFunctionDeclaration);
     FunctionDeclaration declaration = member;
     expect(declaration.returnType, isNotNull);
   }
@@ -16612,7 +16407,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FunctionDeclaration>());
+    expect(member, isFunctionDeclaration);
     FunctionDeclaration declaration = member;
     expect(declaration.externalKeyword, isNotNull);
     expect(declaration.functionExpression, isNotNull);
@@ -16625,7 +16420,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FunctionDeclaration>());
+    expect(member, isFunctionDeclaration);
     FunctionDeclaration declaration = member;
     expect(declaration.externalKeyword, isNotNull);
     expect(declaration.functionExpression, isNotNull);
@@ -16637,7 +16432,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FunctionDeclaration>());
+    expect(member, isFunctionDeclaration);
     FunctionDeclaration declaration = member;
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNotNull);
@@ -16648,7 +16443,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FunctionDeclaration>());
+    expect(member, isFunctionDeclaration);
     FunctionDeclaration declaration = member;
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNotNull);
@@ -16659,7 +16454,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FunctionDeclaration>());
+    expect(member, isFunctionDeclaration);
     FunctionDeclaration declaration = member;
     expect(declaration.externalKeyword, isNotNull);
     expect(declaration.functionExpression, isNotNull);
@@ -16671,7 +16466,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FunctionDeclaration>());
+    expect(member, isFunctionDeclaration);
     FunctionDeclaration declaration = member;
     expect(declaration.externalKeyword, isNotNull);
     expect(declaration.functionExpression, isNotNull);
@@ -16683,7 +16478,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FunctionDeclaration>());
+    expect(member, isFunctionDeclaration);
     FunctionDeclaration declaration = member;
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNotNull);
@@ -16695,7 +16490,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<FunctionDeclaration>());
+    expect(member, isFunctionDeclaration);
     FunctionDeclaration declaration = member;
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNotNull);
@@ -16707,7 +16502,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ClassTypeAlias>());
+    expect(member, isClassTypeAlias);
     ClassTypeAlias typeAlias = member;
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name.name, "C");
@@ -16726,7 +16521,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ClassTypeAlias>());
+    expect(member, isClassTypeAlias);
     ClassTypeAlias typeAlias = member;
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name.name, "C");
@@ -16744,7 +16539,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ClassTypeAlias>());
+    expect(member, isClassTypeAlias);
     ClassTypeAlias typeAlias = member;
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name.name, "C");
@@ -16762,7 +16557,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<ClassTypeAlias>());
+    expect(member, isClassTypeAlias);
     ClassTypeAlias typeAlias = member;
     expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name.name, "C");
@@ -16798,7 +16593,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<TopLevelVariableDeclaration>());
+    expect(member, isTopLevelVariableDeclaration);
     TopLevelVariableDeclaration declaration = member;
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
@@ -16812,7 +16607,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<TopLevelVariableDeclaration>());
+    expect(member, isTopLevelVariableDeclaration);
     TopLevelVariableDeclaration declaration = member;
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
@@ -16829,7 +16624,7 @@
     expect(unit.declarations, hasLength(1));
     TopLevelVariableDeclaration declaration =
         unit.declarations[0] as TopLevelVariableDeclaration;
-    expect(declaration.variables.type, new TypeMatcher<GenericFunctionType>());
+    expect(declaration.variables.type, isGenericFunctionType);
   }
 
   void test_parseCompilationUnitMember_variable_gftType_noReturnType() {
@@ -16854,7 +16649,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<TopLevelVariableDeclaration>());
+    expect(member, isTopLevelVariableDeclaration);
     TopLevelVariableDeclaration declaration = member;
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
@@ -16865,7 +16660,7 @@
     CompilationUnitMember member = parseFullCompilationUnitMember();
     expect(member, isNotNull);
     assertNoErrors();
-    expect(member, new TypeMatcher<TopLevelVariableDeclaration>());
+    expect(member, isTopLevelVariableDeclaration);
     TopLevelVariableDeclaration declaration = member;
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
@@ -17295,7 +17090,7 @@
     {
       var annotation = parameters[0].metadata[0];
       expect(annotation.atSign, isNotNull);
-      expect(annotation.name, new TypeMatcher<SimpleIdentifier>());
+      expect(annotation.name, isSimpleIdentifier);
       expect(annotation.name.name, 'A');
       expect(annotation.period, isNull);
       expect(annotation.constructorName, isNull);
@@ -17305,7 +17100,7 @@
     {
       var annotation = parameters[1].metadata[0];
       expect(annotation.atSign, isNotNull);
-      expect(annotation.name, new TypeMatcher<SimpleIdentifier>());
+      expect(annotation.name, isSimpleIdentifier);
       expect(annotation.name.name, 'B');
       expect(annotation.period, isNull);
       expect(annotation.constructorName, isNull);
@@ -17316,7 +17111,7 @@
     {
       var annotation = parameters[2].metadata[0];
       expect(annotation.atSign, isNotNull);
-      expect(annotation.name, new TypeMatcher<PrefixedIdentifier>());
+      expect(annotation.name, isPrefixedIdentifier);
       expect(annotation.name.name, 'C.foo');
       expect(annotation.period, isNull);
       expect(annotation.constructorName, isNull);
@@ -17327,7 +17122,7 @@
     {
       var annotation = parameters[3].metadata[0];
       expect(annotation.atSign, isNotNull);
-      expect(annotation.name, new TypeMatcher<PrefixedIdentifier>());
+      expect(annotation.name, isPrefixedIdentifier);
       expect(annotation.name.name, 'd.E');
       expect(annotation.period, isNotNull);
       expect(annotation.constructorName, isNotNull);
diff --git a/pkg/analyzer/test/generated/simple_resolver_test.dart b/pkg/analyzer/test/generated/simple_resolver_test.dart
index 55d92dd..634605f 100644
--- a/pkg/analyzer/test/generated/simple_resolver_test.dart
+++ b/pkg/analyzer/test/generated/simple_resolver_test.dart
@@ -1129,20 +1129,19 @@
     await computeAnalysisResult(source);
     assertNoErrors(source);
     verify([source]);
+
     CompilationUnit unit = resolveCompilationUnit(source, library);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(2));
-    Element expectedElement = (declarations[0] as TopLevelVariableDeclaration)
-        .variables
-        .variables[0]
-        .name
-        .staticElement;
-    EngineTestCase.assertInstanceOf((obj) => obj is PropertyInducingElement,
-        PropertyInducingElement, expectedElement);
-    expectedElement = (expectedElement as PropertyInducingElement).getter;
-    Element actualElement =
-        (declarations[1] as ClassDeclaration).metadata[0].name.staticElement;
-    expect(actualElement, same(expectedElement));
+
+    TopLevelVariableDeclaration variableDeclaration = declarations[0];
+    ClassDeclaration classDeclaration = declarations[1];
+
+    PropertyInducingElement expectedElement =
+        variableDeclaration.variables.variables[0].name.staticElement;
+
+    Element actualElement = classDeclaration.metadata[0].name.staticElement;
+    expect(actualElement, same(expectedElement.getter));
   }
 
   test_metadata_field() async {
@@ -1335,17 +1334,15 @@
     CompilationUnit unit = resolveCompilationUnit(source, library);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(2));
-    Element expectedElement = (declarations[0] as TopLevelVariableDeclaration)
-        .variables
-        .variables[0]
-        .name
-        .staticElement;
-    EngineTestCase.assertInstanceOf((obj) => obj is PropertyInducingElement,
-        PropertyInducingElement, expectedElement);
-    expectedElement = (expectedElement as PropertyInducingElement).getter;
-    Element actualElement =
-        (declarations[1] as FunctionTypeAlias).metadata[0].name.staticElement;
-    expect(actualElement, same(expectedElement));
+
+    TopLevelVariableDeclaration variableDeclaration = declarations[0];
+    FunctionTypeAlias functionTypeAlias = declarations[1];
+
+    PropertyInducingElement expectedElement =
+        variableDeclaration.variables.variables[0].name.staticElement;
+
+    Element actualElement = functionTypeAlias.metadata[0].name.staticElement;
+    expect(actualElement, same(expectedElement.getter));
   }
 
   test_method_fromMixin() async {
diff --git a/pkg/analyzer/test/generated/static_type_analyzer_test.dart b/pkg/analyzer/test/generated/static_type_analyzer_test.dart
index fe1a85f..310aa64 100644
--- a/pkg/analyzer/test/generated/static_type_analyzer_test.dart
+++ b/pkg/analyzer/test/generated/static_type_analyzer_test.dart
@@ -1458,9 +1458,7 @@
       List<DartType> expectedOptionalTypes,
       Map<String, DartType> expectedNamedTypes,
       DartType actualType) {
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FunctionType, FunctionType, actualType);
-    FunctionType functionType = actualType as FunctionType;
+    FunctionType functionType = actualType;
     List<DartType> normalTypes = functionType.normalParameterTypes;
     if (expectedNormalTypes == null) {
       expect(normalTypes, hasLength(0));
@@ -1508,8 +1506,6 @@
 
   void _assertType2(DartType expectedType, DartType actualType) {
     if (expectedType is InterfaceTypeImpl) {
-      EngineTestCase.assertInstanceOf(
-          (obj) => obj is InterfaceTypeImpl, InterfaceTypeImpl, actualType);
       _assertType(expectedType, actualType as InterfaceTypeImpl);
     }
     // TODO(brianwilkerson) Compare other kinds of types then make this a shared
diff --git a/pkg/analyzer/test/generated/test_support.dart b/pkg/analyzer/test/generated/test_support.dart
index e44dd22..528bd33 100644
--- a/pkg/analyzer/test/generated/test_support.dart
+++ b/pkg/analyzer/test/generated/test_support.dart
@@ -107,23 +107,6 @@
   void tearDown() {}
 
   /**
-   * Assert that the given object is an instance of the expected class.
-   *
-   * @param expectedClass the class that the object is expected to be an instance of
-   * @param object the object being tested
-   * @return the object that was being tested
-   * @throws Exception if the object is not an instance of the expected class
-   */
-  static Object assertInstanceOf(
-      Predicate<Object> predicate, Type expectedClass, Object object) {
-    if (!predicate(object)) {
-      fail(
-          "Expected instance of $expectedClass, found ${object == null ? "null" : object.runtimeType}");
-    }
-    return object;
-  }
-
-  /**
    * @return the [AstNode] with requested type at offset of the "prefix".
    */
   static AstNode findNode(
diff --git a/pkg/analyzer/test/src/context/context_test.dart b/pkg/analyzer/test/src/context/context_test.dart
index 9ebd97f..df8a221 100644
--- a/pkg/analyzer/test/src/context/context_test.dart
+++ b/pkg/analyzer/test/src/context/context_test.dart
@@ -26,6 +26,7 @@
 import 'package:analyzer/src/task/api/model.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/src/task/html.dart';
+import 'package:analyzer/src/test_utilities/element_type_matchers.dart';
 import 'package:analyzer/src/test_utilities/resource_provider_mixin.dart';
 import 'package:html/dom.dart' show Document;
 import 'package:test/test.dart';
@@ -1671,8 +1672,7 @@
     expect(library, isNotNull);
     Namespace namespace = context.getPublicNamespace(library);
     expect(namespace, isNotNull);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ClassElement, ClassElement, namespace.get("A"));
+    expect(namespace.get("A"), isClassElement);
   }
 
   void test_getResolvedCompilationUnit_library() {
diff --git a/pkg/analyzer/test/src/dart/ast/utilities_test.dart b/pkg/analyzer/test/src/dart/ast/utilities_test.dart
index 1008202..ad836a6 100644
--- a/pkg/analyzer/test/src/dart/ast/utilities_test.dart
+++ b/pkg/analyzer/test/src/dart/ast/utilities_test.dart
@@ -11,11 +11,10 @@
 import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/generated/java_core.dart';
-import 'package:analyzer/src/generated/java_engine.dart' show Predicate;
-import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/testing/ast_test_factory.dart';
 import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:analyzer/src/generated/testing/token_factory.dart';
+import 'package:analyzer/src/test_utilities/ast_type_matchers.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
@@ -72,21 +71,18 @@
   }
 
   void test_binary_bitAnd() {
-    Object value = _getConstantValue("74 & 42");
-    EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
-    expect(value as int, 74 & 42);
+    int value = _getConstantValue("74 & 42");
+    expect(value, 74 & 42);
   }
 
   void test_binary_bitOr() {
-    Object value = _getConstantValue("74 | 42");
-    EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
-    expect(value as int, 74 | 42);
+    int value = _getConstantValue("74 | 42");
+    expect(value, 74 | 42);
   }
 
   void test_binary_bitXor() {
-    Object value = _getConstantValue("74 ^ 42");
-    EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
-    expect(value as int, 74 ^ 42);
+    int value = _getConstantValue("74 ^ 42");
+    expect(value, 74 ^ 42);
   }
 
   void test_binary_divide_double() {
@@ -135,9 +131,8 @@
   }
 
   void test_binary_leftShift() {
-    Object value = _getConstantValue("16 << 2");
-    EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
-    expect(value as int, 64);
+    int value = _getConstantValue("16 << 2");
+    expect(value, 64);
   }
 
   void test_binary_lessThan() {
@@ -241,9 +236,8 @@
   }
 
   void test_binary_rightShift() {
-    Object value = _getConstantValue("64 >> 2");
-    EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
-    expect(value as int, 16);
+    int value = _getConstantValue("64 >> 2");
+    expect(value, 16);
   }
 
   void test_binary_times_double() {
@@ -257,15 +251,13 @@
   }
 
   void test_binary_truncatingDivide_double() {
-    Object value = _getConstantValue("3.2 ~/ 2.3");
-    EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
-    expect(value as int, 1);
+    int value = _getConstantValue("3.2 ~/ 2.3");
+    expect(value, 1);
   }
 
   void test_binary_truncatingDivide_integer() {
-    Object value = _getConstantValue("10 ~/ 3");
-    EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
-    expect(value as int, 3);
+    int value = _getConstantValue("10 ~/ 3");
+    expect(value, 3);
   }
 
   void test_literal_boolean_false() {
@@ -279,23 +271,19 @@
   }
 
   void test_literal_list() {
-    Object value = _getConstantValue("['a', 'b', 'c']");
-    EngineTestCase.assertInstanceOf((obj) => obj is List, List, value);
-    List list = value as List;
-    expect(list.length, 3);
-    expect(list[0], "a");
-    expect(list[1], "b");
-    expect(list[2], "c");
+    List value = _getConstantValue("['a', 'b', 'c']");
+    expect(value.length, 3);
+    expect(value[0], "a");
+    expect(value[1], "b");
+    expect(value[2], "c");
   }
 
   void test_literal_map() {
-    Object value = _getConstantValue("{'a' : 'm', 'b' : 'n', 'c' : 'o'}");
-    EngineTestCase.assertInstanceOf((obj) => obj is Map, Map, value);
-    Map map = value as Map;
-    expect(map.length, 3);
-    expect(map["a"], "m");
-    expect(map["b"], "n");
-    expect(map["c"], "o");
+    Map value = _getConstantValue("{'a' : 'm', 'b' : 'n', 'c' : 'o'}");
+    expect(value.length, 3);
+    expect(value["a"], "m");
+    expect(value["b"], "n");
+    expect(value["c"], "o");
   }
 
   void test_literal_null() {
@@ -339,9 +327,8 @@
   }
 
   void test_unary_bitNot() {
-    Object value = _getConstantValue("~42");
-    EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
-    expect(value as int, ~42);
+    int value = _getConstantValue("~42");
+    expect(value, ~42);
   }
 
   void test_unary_logicalNot() {
@@ -411,8 +398,8 @@
 class NodeLocatorTest extends ParserTestCase {
   void test_range() {
     CompilationUnit unit = parseCompilationUnit("library myLib;");
-    _assertLocate(
-        unit, 4, 10, (node) => node is LibraryDirective, LibraryDirective);
+    var node = _assertLocate(unit, 4, 10);
+    expect(node, isLibraryDirective);
   }
 
   void test_searchWithin_null() {
@@ -422,8 +409,8 @@
 
   void test_searchWithin_offset() {
     CompilationUnit unit = parseCompilationUnit("library myLib;");
-    _assertLocate(
-        unit, 10, 10, (node) => node is SimpleIdentifier, SimpleIdentifier);
+    var node = _assertLocate(unit, 10, 10);
+    expect(node, isSimpleIdentifier);
   }
 
   void test_searchWithin_offsetAfterNode() {
@@ -444,8 +431,11 @@
     expect(node, isNull);
   }
 
-  void _assertLocate(CompilationUnit unit, int start, int end,
-      Predicate<Object> predicate, Type expectedClass) {
+  AstNode _assertLocate(
+    CompilationUnit unit,
+    int start,
+    int end,
+  ) {
     NodeLocator locator = new NodeLocator(start, end);
     AstNode node = locator.searchWithin(unit);
     expect(node, isNotNull);
@@ -453,7 +443,7 @@
     expect(node.offset <= start, isTrue, reason: "Node starts after range");
     expect(node.offset + node.length > end, isTrue,
         reason: "Node ends before range");
-    EngineTestCase.assertInstanceOf(predicate, expectedClass, node);
+    return node;
   }
 }
 
diff --git a/pkg/analyzer/test/src/dart/constant/value_test.dart b/pkg/analyzer/test/src/dart/constant/value_test.dart
index 6825e19..b6c7046 100644
--- a/pkg/analyzer/test/src/dart/constant/value_test.dart
+++ b/pkg/analyzer/test/src/dart/constant/value_test.dart
@@ -400,18 +400,14 @@
   }
 
   void test_getValue_map_empty() {
-    Object result = _mapValue().toMapValue();
-    EngineTestCase.assertInstanceOf((obj) => obj is Map, Map, result);
-    Map map = result as Map;
-    expect(map, hasLength(0));
+    Map result = _mapValue().toMapValue();
+    expect(result, hasLength(0));
   }
 
   void test_getValue_map_valid() {
-    Object result =
+    Map result =
         _mapValue([_stringValue("key"), _stringValue("value")]).toMapValue();
-    EngineTestCase.assertInstanceOf((obj) => obj is Map, Map, result);
-    Map map = result as Map;
-    expect(map, hasLength(1));
+    expect(result, hasLength(1));
   }
 
   void test_getValue_null() {