Replace the sequence isInstanceOf/assign with assist-with-cast in ExpressionParserTestMixin.

pkg/analyzer/test/generated/parser_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.test.generated.parser_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
@@ skipping 3848 matching lines @@
           ParserErrorCode.EXPECTED_TOKEN,
           ParserErrorCode.EXPECTED_TOKEN
         ]);
   }
 
   void test_useOfUnaryPlusOperator() {
     createParser('+x');
     Expression expression = parser.parseUnaryExpression();
     expectNotNullIfNoErrors(expression);
     listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression, new isInstanceOf<SimpleIdentifier>());
-    SimpleIdentifier identifier = expression;
+    var identifier = expression as SimpleIdentifier;
     expect(identifier.isSynthetic, isTrue);
   }
 
   void test_varAndType_field() {
     parseCompilationUnit(
         "class C { var int x; }", [ParserErrorCode.VAR_AND_TYPE]);
   }
 
   @failingTest
   void test_varAndType_local() {
@@ skipping 135 matching lines @@
 
 @reflectiveTest
 class ExpressionParserTest extends ParserTestCase
     with ExpressionParserTestMixin {}
 
 abstract class ExpressionParserTestMixin implements AbstractParserTestCase {
   void test_parseAdditiveExpression_normal() {
     Expression expression = parseAdditiveExpression('x + y');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<BinaryExpression>());
-    BinaryExpression binaryExpression = expression;
+    var binaryExpression = expression as BinaryExpression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.PLUS);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   void test_parseAdditiveExpression_super() {
     Expression expression = parseAdditiveExpression('super + y');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<BinaryExpression>());
-    BinaryExpression binaryExpression = expression;
+    var binaryExpression = expression as BinaryExpression;
     expect(binaryExpression.leftOperand, new isInstanceOf<SuperExpression>());
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.PLUS);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   void test_parseAssignableExpression_expression_args_dot() {
     Expression expression = parseAssignableExpression('(x)(y).z', false);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PropertyAccess>());
-    PropertyAccess propertyAccess = expression;
+    var propertyAccess = expression as PropertyAccess;
     FunctionExpressionInvocation invocation =
         propertyAccess.target as FunctionExpressionInvocation;
     expect(invocation.function, isNotNull);
     expect(invocation.typeArguments, isNull);
     ArgumentList argumentList = invocation.argumentList;
     expect(argumentList, isNotNull);
     expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void
       test_parseAssignableExpression_expression_args_dot_typeParameterComments() {
     enableGenericMethodComments = true;
     Expression expression = parseAssignableExpression('(x)/*<F>*/(y).z', false);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PropertyAccess>());
-    PropertyAccess propertyAccess = expression;
+    var propertyAccess = expression as PropertyAccess;
     FunctionExpressionInvocation invocation =
         propertyAccess.target as FunctionExpressionInvocation;
     expect(invocation.function, isNotNull);
     expect(invocation.typeArguments, isNotNull);
     ArgumentList argumentList = invocation.argumentList;
     expect(argumentList, isNotNull);
     expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAssignableExpression_expression_args_dot_typeParameters() {
     Expression expression = parseAssignableExpression('(x)<F>(y).z', false);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PropertyAccess>());
-    PropertyAccess propertyAccess = expression;
+    var propertyAccess = expression as PropertyAccess;
     FunctionExpressionInvocation invocation =
         propertyAccess.target as FunctionExpressionInvocation;
     expect(invocation.function, isNotNull);
     expect(invocation.typeArguments, isNotNull);
     ArgumentList argumentList = invocation.argumentList;
     expect(argumentList, isNotNull);
     expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAssignableExpression_expression_dot() {
     Expression expression = parseAssignableExpression('(x).y', false);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PropertyAccess>());
-    PropertyAccess propertyAccess = expression;
+    var propertyAccess = expression as PropertyAccess;
     expect(propertyAccess.target, isNotNull);
     expect(propertyAccess.operator.type, TokenType.PERIOD);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAssignableExpression_expression_index() {
     Expression expression = parseAssignableExpression('(x)[y]', false);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<IndexExpression>());
-    IndexExpression indexExpression = expression;
+    var indexExpression = expression as IndexExpression;
     expect(indexExpression.target, isNotNull);
     expect(indexExpression.leftBracket, isNotNull);
     expect(indexExpression.index, isNotNull);
     expect(indexExpression.rightBracket, isNotNull);
   }
 
   void test_parseAssignableExpression_expression_question_dot() {
     Expression expression = parseAssignableExpression('(x)?.y', false);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PropertyAccess>());
-    PropertyAccess propertyAccess = expression;
+    var propertyAccess = expression as PropertyAccess;
     expect(propertyAccess.target, isNotNull);
     expect(propertyAccess.operator.type, TokenType.QUESTION_PERIOD);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAssignableExpression_identifier() {
     Expression expression = parseAssignableExpression('x', false);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleIdentifier>());
-    SimpleIdentifier identifier = expression;
+    var identifier = expression as SimpleIdentifier;
     expect(identifier, isNotNull);
   }
 
   void test_parseAssignableExpression_identifier_args_dot() {
     Expression expression = parseAssignableExpression('x(y).z', false);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PropertyAccess>());
-    PropertyAccess propertyAccess = expression;
+    var propertyAccess = expression as PropertyAccess;
     MethodInvocation invocation = propertyAccess.target as MethodInvocation;
     expect(invocation.methodName.name, "x");
     expect(invocation.typeArguments, isNull);
     ArgumentList argumentList = invocation.argumentList;
     expect(argumentList, isNotNull);
     expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void
       test_parseAssignableExpression_identifier_args_dot_typeParameterComments() {
     enableGenericMethodComments = true;
     Expression expression = parseAssignableExpression('x/*<E>*/(y).z', false);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PropertyAccess>());
-    PropertyAccess propertyAccess = expression;
+    var propertyAccess = expression as PropertyAccess;
     MethodInvocation invocation = propertyAccess.target as MethodInvocation;
     expect(invocation.methodName.name, "x");
     expect(invocation.typeArguments, isNotNull);
     ArgumentList argumentList = invocation.argumentList;
     expect(argumentList, isNotNull);
     expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAssignableExpression_identifier_args_dot_typeParameters() {
     Expression expression = parseAssignableExpression('x<E>(y).z', false);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PropertyAccess>());
-    PropertyAccess propertyAccess = expression;
+    var propertyAccess = expression as PropertyAccess;
     MethodInvocation invocation = propertyAccess.target as MethodInvocation;
     expect(invocation.methodName.name, "x");
     expect(invocation.typeArguments, isNotNull);
     ArgumentList argumentList = invocation.argumentList;
     expect(argumentList, isNotNull);
     expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAssignableExpression_identifier_dot() {
     Expression expression = parseAssignableExpression('x.y', false);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PropertyAccess>());
-    PropertyAccess propertyAccess = expression;
+    var propertyAccess = expression as PropertyAccess;
     expect(propertyAccess.target, isNotNull);
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.operator.type, TokenType.PERIOD);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAssignableExpression_identifier_index() {
     Expression expression = parseAssignableExpression('x[y]', false);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<IndexExpression>());
-    IndexExpression indexExpression = expression;
+    var indexExpression = expression as IndexExpression;
     expect(indexExpression.target, isNotNull);
     expect(indexExpression.leftBracket, isNotNull);
     expect(indexExpression.index, isNotNull);
     expect(indexExpression.rightBracket, isNotNull);
   }
 
   void test_parseAssignableExpression_identifier_question_dot() {
     Expression expression = parseAssignableExpression('x?.y', false);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PropertyAccess>());
-    PropertyAccess propertyAccess = expression;
+    var propertyAccess = expression as PropertyAccess;
     expect(propertyAccess.target, isNotNull);
     expect(propertyAccess.operator.type, TokenType.QUESTION_PERIOD);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAssignableExpression_super_dot() {
     Expression expression = parseAssignableExpression('super.y', false);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PropertyAccess>());
-    PropertyAccess propertyAccess = expression;
+    var propertyAccess = expression as PropertyAccess;
     EngineTestCase.assertInstanceOf((obj) => obj is SuperExpression,
         SuperExpression, propertyAccess.target);
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAssignableExpression_super_index() {
     Expression expression = parseAssignableExpression('super[y]', false);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<IndexExpression>());
-    IndexExpression indexExpression = expression;
+    var indexExpression = expression as IndexExpression;
     expect(indexExpression.target, new isInstanceOf<SuperExpression>());
     expect(indexExpression.leftBracket, isNotNull);
     expect(indexExpression.index, isNotNull);
     expect(indexExpression.rightBracket, isNotNull);
   }
 
   void test_parseAssignableSelector_dot() {
     Expression expression = parseAssignableSelector('.x', null, true);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PropertyAccess>());
-    PropertyAccess propertyAccess = expression;
+    var propertyAccess = expression as PropertyAccess;
     expect(propertyAccess.operator.type, TokenType.PERIOD);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAssignableSelector_index() {
     Expression expression = parseAssignableSelector('[x]', null, true);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<IndexExpression>());
-    IndexExpression indexExpression = expression;
+    var indexExpression = expression as IndexExpression;
     expect(indexExpression.leftBracket, isNotNull);
     expect(indexExpression.index, isNotNull);
     expect(indexExpression.rightBracket, isNotNull);
   }
 
   void test_parseAssignableSelector_none() {
     Expression expression =
         parseAssignableSelector(';', astFactory.simpleIdentifier(null), true);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleIdentifier>());
-    SimpleIdentifier identifier = expression;
+    var identifier = expression as SimpleIdentifier;
     expect(identifier, isNotNull);
   }
 
   void test_parseAssignableSelector_question_dot() {
     Expression expression = parseAssignableSelector('?.x', null, true);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PropertyAccess>());
-    PropertyAccess propertyAccess = expression;
+    var propertyAccess = expression as PropertyAccess;
     expect(propertyAccess.operator.type, TokenType.QUESTION_PERIOD);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAwaitExpression() {
     AwaitExpression expression = parseAwaitExpression('await x;');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.awaitKeyword, isNotNull);
     expect(expression.expression, isNotNull);
   }
 
   void test_parseBitwiseAndExpression_normal() {
     Expression expression = parseBitwiseAndExpression('x & y');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<BinaryExpression>());
-    BinaryExpression binaryExpression = expression;
+    var binaryExpression = expression as BinaryExpression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.AMPERSAND);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   void test_parseBitwiseAndExpression_super() {
     Expression expression = parseBitwiseAndExpression('super & y');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<BinaryExpression>());
-    BinaryExpression binaryExpression = expression;
+    var binaryExpression = expression as BinaryExpression;
     expect(binaryExpression.leftOperand, new isInstanceOf<SuperExpression>());
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.AMPERSAND);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   void test_parseBitwiseOrExpression_normal() {
     Expression expression = parseBitwiseOrExpression('x | y');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<BinaryExpression>());
-    BinaryExpression binaryExpression = expression;
+    var binaryExpression = expression as BinaryExpression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.BAR);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   void test_parseBitwiseOrExpression_super() {
     Expression expression = parseBitwiseOrExpression('super | y');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<BinaryExpression>());
-    BinaryExpression binaryExpression = expression;
+    var binaryExpression = expression as BinaryExpression;
     expect(binaryExpression.leftOperand, new isInstanceOf<SuperExpression>());
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.BAR);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   void test_parseBitwiseXorExpression_normal() {
     Expression expression = parseBitwiseXorExpression('x ^ y');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<BinaryExpression>());
-    BinaryExpression binaryExpression = expression;
+    var binaryExpression = expression as BinaryExpression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.CARET);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   void test_parseBitwiseXorExpression_super() {
     Expression expression = parseBitwiseXorExpression('super ^ y');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<BinaryExpression>());
-    BinaryExpression binaryExpression = expression;
+    var binaryExpression = expression as BinaryExpression;
     expect(binaryExpression.leftOperand, new isInstanceOf<SuperExpression>());
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.CARET);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   void test_parseCascadeSection_i() {
     Expression expression = parseCascadeSection('..[i]');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<IndexExpression>());
-    IndexExpression section = expression;
+    var section = expression as IndexExpression;
     expect(section.target, isNull);
     expect(section.leftBracket, isNotNull);
     expect(section.index, isNotNull);
     expect(section.rightBracket, isNotNull);
   }
 
   void test_parseCascadeSection_ia() {
     Expression expression = parseCascadeSection('..[i](b)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
-    FunctionExpressionInvocation section = expression;
+    var section = expression as FunctionExpressionInvocation;
     expect(section.function, new isInstanceOf<IndexExpression>());
     expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
   }
 
   void test_parseCascadeSection_ia_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parseCascadeSection('..[i]/*<E>*/(b)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
-    FunctionExpressionInvocation section = expression;
+    var section = expression as FunctionExpressionInvocation;
     expect(section.function, new isInstanceOf<IndexExpression>());
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
   }
 
   void test_parseCascadeSection_ia_typeArguments() {
     Expression expression = parseCascadeSection('..[i]<E>(b)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
-    FunctionExpressionInvocation section = expression;
+    var section = expression as FunctionExpressionInvocation;
     expect(section.function, new isInstanceOf<IndexExpression>());
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
   }
 
   void test_parseCascadeSection_ii() {
     Expression expression = parseCascadeSection('..a(b).c(d)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MethodInvocation>());
-    MethodInvocation section = expression;
+    var section = expression as MethodInvocation;
     expect(section.target, new isInstanceOf<MethodInvocation>());
     expect(section.operator, isNotNull);
     expect(section.methodName, isNotNull);
     expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_ii_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parseCascadeSection('..a/*<E>*/(b).c/*<F>*/(d)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MethodInvocation>());
-    MethodInvocation section = expression;
+    var section = expression as MethodInvocation;
     expect(section.target, new isInstanceOf<MethodInvocation>());
     expect(section.operator, isNotNull);
     expect(section.methodName, isNotNull);
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_ii_typeArguments() {
     Expression expression = parseCascadeSection('..a<E>(b).c<F>(d)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MethodInvocation>());
-    MethodInvocation section = expression;
+    var section = expression as MethodInvocation;
     expect(section.target, new isInstanceOf<MethodInvocation>());
     expect(section.operator, isNotNull);
     expect(section.methodName, isNotNull);
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_p() {
     Expression expression = parseCascadeSection('..a');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PropertyAccess>());
-    PropertyAccess section = expression;
+    var section = expression as PropertyAccess;
     expect(section.target, isNull);
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
 
   void test_parseCascadeSection_p_assign() {
     Expression expression = parseCascadeSection('..a = 3');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<AssignmentExpression>());
-    AssignmentExpression section = expression;
+    var section = expression as AssignmentExpression;
     expect(section.leftHandSide, isNotNull);
     expect(section.operator, isNotNull);
     Expression rhs = section.rightHandSide;
     expect(rhs, isNotNull);
   }
 
   void test_parseCascadeSection_p_assign_withCascade() {
     Expression expression = parseCascadeSection('..a = 3..m()');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<AssignmentExpression>());
-    AssignmentExpression section = expression;
+    var section = expression as AssignmentExpression;
     expect(section.leftHandSide, isNotNull);
     expect(section.operator, isNotNull);
     Expression rhs = section.rightHandSide;
     EngineTestCase.assertInstanceOf(
         (obj) => obj is IntegerLiteral, IntegerLiteral, rhs);
   }
 
   void test_parseCascadeSection_p_assign_withCascade_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parseCascadeSection('..a = 3..m/*<E>*/()');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<AssignmentExpression>());
-    AssignmentExpression section = expression;
+    var section = expression as AssignmentExpression;
     expect(section.leftHandSide, isNotNull);
     expect(section.operator, isNotNull);
     Expression rhs = section.rightHandSide;
     EngineTestCase.assertInstanceOf(
         (obj) => obj is IntegerLiteral, IntegerLiteral, rhs);
   }
 
   void test_parseCascadeSection_p_assign_withCascade_typeArguments() {
     Expression expression = parseCascadeSection('..a = 3..m<E>()');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<AssignmentExpression>());
-    AssignmentExpression section = expression;
+    var section = expression as AssignmentExpression;
     expect(section.leftHandSide, isNotNull);
     expect(section.operator, isNotNull);
     Expression rhs = section.rightHandSide;
     EngineTestCase.assertInstanceOf(
         (obj) => obj is IntegerLiteral, IntegerLiteral, rhs);
   }
 
   void test_parseCascadeSection_p_builtIn() {
     Expression expression = parseCascadeSection('..as');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PropertyAccess>());
-    PropertyAccess section = expression;
+    var section = expression as PropertyAccess;
     expect(section.target, isNull);
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
 
   void test_parseCascadeSection_pa() {
     Expression expression = parseCascadeSection('..a(b)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MethodInvocation>());
-    MethodInvocation section = expression;
+    var section = expression as MethodInvocation;
     expect(section.target, isNull);
     expect(section.operator, isNotNull);
     expect(section.methodName, isNotNull);
     expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_pa_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parseCascadeSection('..a/*<E>*/(b)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MethodInvocation>());
-    MethodInvocation section = expression;
+    var section = expression as MethodInvocation;
     expect(section.target, isNull);
     expect(section.operator, isNotNull);
     expect(section.methodName, isNotNull);
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_pa_typeArguments() {
     Expression expression = parseCascadeSection('..a<E>(b)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MethodInvocation>());
-    MethodInvocation section = expression;
+    var section = expression as MethodInvocation;
     expect(section.target, isNull);
     expect(section.operator, isNotNull);
     expect(section.methodName, isNotNull);
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_paa() {
     Expression expression = parseCascadeSection('..a(b)(c)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
-    FunctionExpressionInvocation section = expression;
+    var section = expression as FunctionExpressionInvocation;
     expect(section.function, new isInstanceOf<MethodInvocation>());
     expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_paa_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parseCascadeSection('..a/*<E>*/(b)/*<F>*/(c)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
-    FunctionExpressionInvocation section = expression;
+    var section = expression as FunctionExpressionInvocation;
     expect(section.function, new isInstanceOf<MethodInvocation>());
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_paa_typeArguments() {
     Expression expression = parseCascadeSection('..a<E>(b)<F>(c)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
-    FunctionExpressionInvocation section = expression;
+    var section = expression as FunctionExpressionInvocation;
     expect(section.function, new isInstanceOf<MethodInvocation>());
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_paapaa() {
     Expression expression = parseCascadeSection('..a(b)(c).d(e)(f)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
-    FunctionExpressionInvocation section = expression;
+    var section = expression as FunctionExpressionInvocation;
     expect(section.function, new isInstanceOf<MethodInvocation>());
     expect(section.typeArguments, isNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_paapaa_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression =
         parseCascadeSection('..a/*<E>*/(b)/*<F>*/(c).d/*<G>*/(e)/*<H>*/(f)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
-    FunctionExpressionInvocation section = expression;
+    var section = expression as FunctionExpressionInvocation;
     expect(section.function, new isInstanceOf<MethodInvocation>());
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_paapaa_typeArguments() {
     Expression expression =
         parseCascadeSection('..a<E>(b)<F>(c).d<G>(e)<H>(f)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
-    FunctionExpressionInvocation section = expression;
+    var section = expression as FunctionExpressionInvocation;
     expect(section.function, new isInstanceOf<MethodInvocation>());
     expect(section.typeArguments, isNotNull);
     expect(section.argumentList, isNotNull);
     expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_pap() {
     Expression expression = parseCascadeSection('..a(b).c');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PropertyAccess>());
-    PropertyAccess section = expression;
+    var section = expression as PropertyAccess;
     expect(section.target, isNotNull);
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
 
   void test_parseCascadeSection_pap_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parseCascadeSection('..a/*<E>*/(b).c');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PropertyAccess>());
-    PropertyAccess section = expression;
+    var section = expression as PropertyAccess;
     expect(section.target, isNotNull);
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
 
   void test_parseCascadeSection_pap_typeArguments() {
     Expression expression = parseCascadeSection('..a<E>(b).c');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PropertyAccess>());
-    PropertyAccess section = expression;
+    var section = expression as PropertyAccess;
     expect(section.target, isNotNull);
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
 
   void test_parseConditionalExpression() {
     ConditionalExpression expression = parseConditionalExpression('x ? y : z');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.condition, isNotNull);
@@ skipping 15 matching lines @@
     expect(name.type, isNotNull);
     expect(name.period, isNull);
     expect(name.name, isNull);
     expect(instanceCreation.argumentList, isNotNull);
   }
 
   void test_parseConstExpression_listLiteral_typed() {
     Expression expression = parseConstExpression('const <A> []');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<ListLiteral>());
-    ListLiteral literal = expression;
+    var literal = expression as ListLiteral;
     expect(literal.constKeyword, isNotNull);
     expect(literal.typeArguments, isNotNull);
     expect(literal.leftBracket, isNotNull);
     expect(literal.elements, hasLength(0));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseConstExpression_listLiteral_typed_genericComment() {
     enableGenericMethodComments = true;
     Expression expression = parseConstExpression('const /*<A>*/ []');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<ListLiteral>());
-    ListLiteral literal = expression;
+    var literal = expression as ListLiteral;
     expect(literal.constKeyword, isNotNull);
     expect(literal.typeArguments, isNotNull);
     expect(literal.leftBracket, isNotNull);
     expect(literal.elements, hasLength(0));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseConstExpression_listLiteral_untyped() {
     Expression expression = parseConstExpression('const []');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<ListLiteral>());
-    ListLiteral literal = expression;
+    var literal = expression as ListLiteral;
     expect(literal.constKeyword, isNotNull);
     expect(literal.typeArguments, isNull);
     expect(literal.leftBracket, isNotNull);
     expect(literal.elements, hasLength(0));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseConstExpression_mapLiteral_typed() {
     Expression expression = parseConstExpression('const <A, B> {}');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MapLiteral>());
-    MapLiteral literal = expression;
+    var literal = expression as MapLiteral;
     expect(literal.leftBracket, isNotNull);
     expect(literal.entries, hasLength(0));
     expect(literal.rightBracket, isNotNull);
     expect(literal.typeArguments, isNotNull);
   }
 
   void test_parseConstExpression_mapLiteral_typed_genericComment() {
     enableGenericMethodComments = true;
     Expression expression = parseConstExpression('const /*<A, B>*/ {}');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MapLiteral>());
-    MapLiteral literal = expression;
+    var literal = expression as MapLiteral;
     expect(literal.leftBracket, isNotNull);
     expect(literal.entries, hasLength(0));
     expect(literal.rightBracket, isNotNull);
     expect(literal.typeArguments, isNotNull);
   }
 
   void test_parseConstExpression_mapLiteral_untyped() {
     Expression expression = parseConstExpression('const {}');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MapLiteral>());
-    MapLiteral literal = expression;
+    var literal = expression as MapLiteral;
     expect(literal.leftBracket, isNotNull);
     expect(literal.entries, hasLength(0));
     expect(literal.rightBracket, isNotNull);
     expect(literal.typeArguments, isNull);
   }
 
   void test_parseEqualityExpression_normal() {
     BinaryExpression expression = parseEqualityExpression('x == y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.leftOperand, isNotNull);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.EQ_EQ);
     expect(expression.rightOperand, isNotNull);
   }
 
   void test_parseEqualityExpression_super() {
     BinaryExpression expression = parseEqualityExpression('super == y');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.leftOperand, new isInstanceOf<SuperExpression>());
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.EQ_EQ);
     expect(expression.rightOperand, isNotNull);
   }
 
   void test_parseExpression_assign() {
     // TODO(brianwilkerson) Implement more tests for this method.
     Expression expression = parseExpression('x = y');
-    expect(expression, new isInstanceOf<AssignmentExpression>());
-    AssignmentExpression assignmentExpression = expression;
+    var assignmentExpression = expression as AssignmentExpression;
     expect(assignmentExpression.leftHandSide, isNotNull);
     expect(assignmentExpression.operator, isNotNull);
     expect(assignmentExpression.operator.type, TokenType.EQ);
     expect(assignmentExpression.rightHandSide, isNotNull);
   }
 
   void test_parseExpression_assign_compound() {
     enableLazyAssignmentOperators = true;
     Expression expression = parseExpression('x ||= y');
-    expect(expression, new isInstanceOf<AssignmentExpression>());
-    AssignmentExpression assignmentExpression = expression;
+    var assignmentExpression = expression as AssignmentExpression;
     expect(assignmentExpression.leftHandSide, isNotNull);
     expect(assignmentExpression.operator, isNotNull);
     expect(assignmentExpression.operator.type, TokenType.BAR_BAR_EQ);
     expect(assignmentExpression.rightHandSide, isNotNull);
   }
 
   void test_parseExpression_comparison() {
     Expression expression = parseExpression('--a.b == c');
-    expect(expression, new isInstanceOf<BinaryExpression>());
-    BinaryExpression binaryExpression = expression;
+    var binaryExpression = expression as BinaryExpression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.EQ_EQ);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   void test_parseExpression_function_async() {
     Expression expression = parseExpression('() async {}');
-    expect(expression, new isInstanceOf<FunctionExpression>());
-    FunctionExpression functionExpression = expression;
+    var functionExpression = expression as FunctionExpression;
     expect(functionExpression.body, isNotNull);
     expect(functionExpression.body.isAsynchronous, isTrue);
     expect(functionExpression.body.isGenerator, isFalse);
     expect(functionExpression.parameters, isNotNull);
   }
 
   void test_parseExpression_function_asyncStar() {
     Expression expression = parseExpression('() async* {}');
-    expect(expression, new isInstanceOf<FunctionExpression>());
-    FunctionExpression functionExpression = expression;
+    var functionExpression = expression as FunctionExpression;
     expect(functionExpression.body, isNotNull);
     expect(functionExpression.body.isAsynchronous, isTrue);
     expect(functionExpression.body.isGenerator, isTrue);
     expect(functionExpression.parameters, isNotNull);
   }
 
   void test_parseExpression_function_sync() {
     Expression expression = parseExpression('() {}');
-    expect(expression, new isInstanceOf<FunctionExpression>());
-    FunctionExpression functionExpression = expression;
+    var functionExpression = expression as FunctionExpression;
     expect(functionExpression.body, isNotNull);
     expect(functionExpression.body.isAsynchronous, isFalse);
     expect(functionExpression.body.isGenerator, isFalse);
     expect(functionExpression.parameters, isNotNull);
   }
 
   void test_parseExpression_function_syncStar() {
     Expression expression = parseExpression('() sync* {}');
-    expect(expression, new isInstanceOf<FunctionExpression>());
-    FunctionExpression functionExpression = expression;
+    var functionExpression = expression as FunctionExpression;
     expect(functionExpression.body, isNotNull);
     expect(functionExpression.body.isAsynchronous, isFalse);
     expect(functionExpression.body.isGenerator, isTrue);
     expect(functionExpression.parameters, isNotNull);
   }
 
   void test_parseExpression_invokeFunctionExpression() {
     Expression expression = parseExpression('(a) {return a + a;} (3)');
-    expect(expression, new isInstanceOf<FunctionExpressionInvocation>());
-    FunctionExpressionInvocation invocation = expression;
+    var invocation = expression as FunctionExpressionInvocation;
     expect(invocation.function, new isInstanceOf<FunctionExpression>());
     FunctionExpression functionExpression =
         invocation.function as FunctionExpression;
     expect(functionExpression.parameters, isNotNull);
     expect(functionExpression.body, isNotNull);
     expect(invocation.typeArguments, isNull);
     ArgumentList list = invocation.argumentList;
     expect(list, isNotNull);
     expect(list.arguments, hasLength(1));
   }
 
   void test_parseExpression_nonAwait() {
     Expression expression = parseExpression('await()');
-    expect(expression, new isInstanceOf<MethodInvocation>());
-    MethodInvocation invocation = expression;
+    var invocation = expression as MethodInvocation;
     expect(invocation.methodName.name, 'await');
     expect(invocation.typeArguments, isNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   void test_parseExpression_superMethodInvocation() {
     Expression expression = parseExpression('super.m()');
-    expect(expression, new isInstanceOf<MethodInvocation>());
-    MethodInvocation invocation = expression;
+    var invocation = expression as MethodInvocation;
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.typeArguments, isNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   void test_parseExpression_superMethodInvocation_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parseExpression('super.m/*<E>*/()');
-    expect(expression, new isInstanceOf<MethodInvocation>());
-    MethodInvocation invocation = expression;
+    var invocation = expression as MethodInvocation;
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.typeArguments, isNotNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   void test_parseExpression_superMethodInvocation_typeArguments() {
     Expression expression = parseExpression('super.m<E>()');
-    expect(expression, new isInstanceOf<MethodInvocation>());
-    MethodInvocation invocation = expression;
+    var invocation = expression as MethodInvocation;
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.typeArguments, isNotNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   void test_parseExpressionList_multiple() {
     List<Expression> result = parseExpressionList('1, 2, 3');
     expect(result, isNotNull);
     assertNoErrors();
     expect(result, hasLength(3));
   }
 
   void test_parseExpressionList_single() {
     List<Expression> result = parseExpressionList('1');
     expect(result, isNotNull);
     assertNoErrors();
     expect(result, hasLength(1));
   }
 
   void test_parseExpressionWithoutCascade_assign() {
     // TODO(brianwilkerson) Implement more tests for this method.
     Expression expression = parseExpressionWithoutCascade('x = y');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<AssignmentExpression>());
-    AssignmentExpression assignmentExpression = expression;
+    var assignmentExpression = expression as AssignmentExpression;
     expect(assignmentExpression.leftHandSide, isNotNull);
     expect(assignmentExpression.operator, isNotNull);
     expect(assignmentExpression.operator.type, TokenType.EQ);
     expect(assignmentExpression.rightHandSide, isNotNull);
   }
 
   void test_parseExpressionWithoutCascade_comparison() {
     Expression expression = parseExpressionWithoutCascade('--a.b == c');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<BinaryExpression>());
-    BinaryExpression binaryExpression = expression;
+    var binaryExpression = expression as BinaryExpression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.EQ_EQ);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   void test_parseExpressionWithoutCascade_superMethodInvocation() {
     Expression expression = parseExpressionWithoutCascade('super.m()');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MethodInvocation>());
-    MethodInvocation invocation = expression;
+    var invocation = expression as MethodInvocation;
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.typeArguments, isNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   void
       test_parseExpressionWithoutCascade_superMethodInvocation_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parseExpressionWithoutCascade('super.m/*<E>*/()');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MethodInvocation>());
-    MethodInvocation invocation = expression;
+    var invocation = expression as MethodInvocation;
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.typeArguments, isNotNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   void
       test_parseExpressionWithoutCascade_superMethodInvocation_typeArguments() {
     Expression expression = parseExpressionWithoutCascade('super.m<E>()');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MethodInvocation>());
-    MethodInvocation invocation = expression;
+    var invocation = expression as MethodInvocation;
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.typeArguments, isNotNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   void test_parseFunctionExpression_body_inExpression() {
     FunctionExpression expression = parseFunctionExpression('(int i) => i++');
     expect(expression, isNotNull);
     assertNoErrors();
@@ skipping 326 matching lines @@
     expect(literal.typeArguments, isNotNull);
     expect(literal.leftBracket, isNotNull);
     expect(literal.elements, hasLength(1));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseListOrMapLiteral_list_noType() {
     TypedLiteral literal = parseListOrMapLiteral(null, '[1]');
     expect(literal, isNotNull);
     assertNoErrors();
-    expect(literal, new isInstanceOf<ListLiteral>());
-    ListLiteral listLiteral = literal;
+    var listLiteral = literal as ListLiteral;
     expect(listLiteral.constKeyword, isNull);
     expect(listLiteral.typeArguments, isNull);
     expect(listLiteral.leftBracket, isNotNull);
     expect(listLiteral.elements, hasLength(1));
     expect(listLiteral.rightBracket, isNotNull);
   }
 
   void test_parseListOrMapLiteral_list_type() {
     TypedLiteral literal = parseListOrMapLiteral(null, '<int> [1]');
     expect(literal, isNotNull);
     assertNoErrors();
-    expect(literal, new isInstanceOf<ListLiteral>());
-    ListLiteral listLiteral = literal;
+    var listLiteral = literal as ListLiteral;
     expect(listLiteral.constKeyword, isNull);
     expect(listLiteral.typeArguments, isNotNull);
     expect(listLiteral.leftBracket, isNotNull);
     expect(listLiteral.elements, hasLength(1));
     expect(listLiteral.rightBracket, isNotNull);
   }
 
   void test_parseListOrMapLiteral_map_noType() {
     TypedLiteral literal = parseListOrMapLiteral(null, "{'1' : 1}");
     expect(literal, isNotNull);
     assertNoErrors();
-    expect(literal, new isInstanceOf<MapLiteral>());
-    MapLiteral mapLiteral = literal;
+    var mapLiteral = literal as MapLiteral;
     expect(mapLiteral.constKeyword, isNull);
     expect(mapLiteral.typeArguments, isNull);
     expect(mapLiteral.leftBracket, isNotNull);
     expect(mapLiteral.entries, hasLength(1));
     expect(mapLiteral.rightBracket, isNotNull);
   }
 
   void test_parseListOrMapLiteral_map_type() {
     TypedLiteral literal =
         parseListOrMapLiteral(null, "<String, int> {'1' : 1}");
     expect(literal, isNotNull);
     assertNoErrors();
-    expect(literal, new isInstanceOf<MapLiteral>());
-    MapLiteral mapLiteral = literal;
+    var mapLiteral = literal as MapLiteral;
     expect(mapLiteral.constKeyword, isNull);
     expect(mapLiteral.typeArguments, isNotNull);
     expect(mapLiteral.leftBracket, isNotNull);
     expect(mapLiteral.entries, hasLength(1));
     expect(mapLiteral.rightBracket, isNotNull);
   }
 
   void test_parseLogicalAndExpression() {
     Expression expression = parseLogicalAndExpression('x && y');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<BinaryExpression>());
-    BinaryExpression binaryExpression = expression;
+    var binaryExpression = expression as BinaryExpression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.AMPERSAND_AMPERSAND);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   void test_parseLogicalOrExpression() {
     Expression expression = parseLogicalOrExpression('x || y');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<BinaryExpression>());
-    BinaryExpression binaryExpression = expression;
+    var binaryExpression = expression as BinaryExpression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.BAR_BAR);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   void test_parseMapLiteral_empty() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.CONST);
     MapLiteral literal = parseMapLiteral(token, '<String, int>', '{}');
     expect(literal, isNotNull);
@@ skipping 47 matching lines @@
     assertNoErrors();
     expect(entry.key, isNotNull);
     expect(entry.separator, isNotNull);
     expect(entry.value, isNotNull);
   }
 
   void test_parseMultiplicativeExpression_normal() {
     Expression expression = parseMultiplicativeExpression('x * y');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<BinaryExpression>());
-    BinaryExpression binaryExpression = expression;
+    var binaryExpression = expression as BinaryExpression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.STAR);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   void test_parseMultiplicativeExpression_super() {
     Expression expression = parseMultiplicativeExpression('super * y');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<BinaryExpression>());
-    BinaryExpression binaryExpression = expression;
+    var binaryExpression = expression as BinaryExpression;
     expect(binaryExpression.leftOperand, new isInstanceOf<SuperExpression>());
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.STAR);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   void test_parseNewExpression() {
     InstanceCreationExpression expression = parseNewExpression('new A()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.keyword, isNotNull);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     expect(name.type, isNotNull);
     expect(name.period, isNull);
     expect(name.name, isNull);
     expect(expression.argumentList, isNotNull);
   }
 
   void test_parsePostfixExpression_decrement() {
     Expression expression = parsePostfixExpression('i--');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PostfixExpression>());
-    PostfixExpression postfixExpression = expression;
+    var postfixExpression = expression as PostfixExpression;
     expect(postfixExpression.operand, isNotNull);
     expect(postfixExpression.operator, isNotNull);
     expect(postfixExpression.operator.type, TokenType.MINUS_MINUS);
   }
 
   void test_parsePostfixExpression_increment() {
     Expression expression = parsePostfixExpression('i++');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PostfixExpression>());
-    PostfixExpression postfixExpression = expression;
+    var postfixExpression = expression as PostfixExpression;
     expect(postfixExpression.operand, isNotNull);
     expect(postfixExpression.operator, isNotNull);
     expect(postfixExpression.operator.type, TokenType.PLUS_PLUS);
   }
 
   void test_parsePostfixExpression_none_indexExpression() {
     Expression expression = parsePostfixExpression('a[0]');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<IndexExpression>());
-    IndexExpression indexExpression = expression;
+    var indexExpression = expression as IndexExpression;
     expect(indexExpression.target, isNotNull);
     expect(indexExpression.index, isNotNull);
   }
 
   void test_parsePostfixExpression_none_methodInvocation() {
     Expression expression = parsePostfixExpression('a.m()');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MethodInvocation>());
-    MethodInvocation methodInvocation = expression;
+    var methodInvocation = expression as MethodInvocation;
     expect(methodInvocation.target, isNotNull);
     expect(methodInvocation.operator.type, TokenType.PERIOD);
     expect(methodInvocation.methodName, isNotNull);
     expect(methodInvocation.typeArguments, isNull);
     expect(methodInvocation.argumentList, isNotNull);
   }
 
   void test_parsePostfixExpression_none_methodInvocation_question_dot() {
     Expression expression = parsePostfixExpression('a?.m()');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MethodInvocation>());
-    MethodInvocation methodInvocation = expression;
+    var methodInvocation = expression as MethodInvocation;
     expect(methodInvocation.target, isNotNull);
     expect(methodInvocation.operator.type, TokenType.QUESTION_PERIOD);
     expect(methodInvocation.methodName, isNotNull);
     expect(methodInvocation.typeArguments, isNull);
     expect(methodInvocation.argumentList, isNotNull);
   }
 
   void
       test_parsePostfixExpression_none_methodInvocation_question_dot_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parsePostfixExpression('a?.m/*<E>*/()');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MethodInvocation>());
-    MethodInvocation methodInvocation = expression;
+    var methodInvocation = expression as MethodInvocation;
     expect(methodInvocation.target, isNotNull);
     expect(methodInvocation.operator.type, TokenType.QUESTION_PERIOD);
     expect(methodInvocation.methodName, isNotNull);
     expect(methodInvocation.typeArguments, isNotNull);
     expect(methodInvocation.argumentList, isNotNull);
   }
 
   void
       test_parsePostfixExpression_none_methodInvocation_question_dot_typeArguments() {
     Expression expression = parsePostfixExpression('a?.m<E>()');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MethodInvocation>());
-    MethodInvocation methodInvocation = expression;
+    var methodInvocation = expression as MethodInvocation;
     expect(methodInvocation.target, isNotNull);
     expect(methodInvocation.operator.type, TokenType.QUESTION_PERIOD);
     expect(methodInvocation.methodName, isNotNull);
     expect(methodInvocation.typeArguments, isNotNull);
     expect(methodInvocation.argumentList, isNotNull);
   }
 
   void
       test_parsePostfixExpression_none_methodInvocation_typeArgumentComments() {
     enableGenericMethodComments = true;
     Expression expression = parsePostfixExpression('a.m/*<E>*/()');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MethodInvocation>());
-    MethodInvocation methodInvocation = expression;
+    var methodInvocation = expression as MethodInvocation;
     expect(methodInvocation.target, isNotNull);
     expect(methodInvocation.operator.type, TokenType.PERIOD);
     expect(methodInvocation.methodName, isNotNull);
     expect(methodInvocation.typeArguments, isNotNull);
     expect(methodInvocation.argumentList, isNotNull);
   }
 
   void test_parsePostfixExpression_none_methodInvocation_typeArguments() {
     Expression expression = parsePostfixExpression('a.m<E>()');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MethodInvocation>());
-    MethodInvocation methodInvocation = expression;
+    var methodInvocation = expression as MethodInvocation;
     expect(methodInvocation.target, isNotNull);
     expect(methodInvocation.operator.type, TokenType.PERIOD);
     expect(methodInvocation.methodName, isNotNull);
     expect(methodInvocation.typeArguments, isNotNull);
     expect(methodInvocation.argumentList, isNotNull);
   }
 
   void test_parsePostfixExpression_none_propertyAccess() {
     Expression expression = parsePostfixExpression('a.b');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PrefixedIdentifier>());
-    PrefixedIdentifier identifier = expression;
+    var identifier = expression as PrefixedIdentifier;
     expect(identifier.prefix, isNotNull);
     expect(identifier.identifier, isNotNull);
   }
 
   void test_parsePrefixedIdentifier_noPrefix() {
     String lexeme = "bar";
     Identifier identifier = parsePrefixedIdentifier(lexeme);
     expect(identifier, isNotNull);
     assertNoErrors();
-    expect(identifier, new isInstanceOf<SimpleIdentifier>());
-    SimpleIdentifier simpleIdentifier = identifier;
+    var simpleIdentifier = identifier as SimpleIdentifier;
     expect(simpleIdentifier.token, isNotNull);
     expect(simpleIdentifier.name, lexeme);
   }
 
   void test_parsePrefixedIdentifier_prefix() {
     String lexeme = "foo.bar";
     Identifier identifier = parsePrefixedIdentifier(lexeme);
     expect(identifier, isNotNull);
     assertNoErrors();
-    expect(identifier, new isInstanceOf<PrefixedIdentifier>());
-    PrefixedIdentifier prefixedIdentifier = identifier;
+    var prefixedIdentifier = identifier as PrefixedIdentifier;
     expect(prefixedIdentifier.prefix.name, "foo");
     expect(prefixedIdentifier.period, isNotNull);
     expect(prefixedIdentifier.identifier.name, "bar");
   }
 
   void test_parsePrimaryExpression_const() {
     Expression expression = parsePrimaryExpression('const A()');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, isNotNull);
   }
 
   void test_parsePrimaryExpression_double() {
     String doubleLiteral = "3.2e4";
     Expression expression = parsePrimaryExpression(doubleLiteral);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<DoubleLiteral>());
-    DoubleLiteral literal = expression;
+    var literal = expression as DoubleLiteral;
     expect(literal.literal, isNotNull);
     expect(literal.value, double.parse(doubleLiteral));
   }
 
   void test_parsePrimaryExpression_false() {
     Expression expression = parsePrimaryExpression('false');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<BooleanLiteral>());
-    BooleanLiteral literal = expression;
+    var literal = expression as BooleanLiteral;
     expect(literal.literal, isNotNull);
     expect(literal.value, isFalse);
   }
 
   void test_parsePrimaryExpression_function_arguments() {
     Expression expression = parsePrimaryExpression('(int i) => i + 1');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<FunctionExpression>());
-    FunctionExpression functionExpression = expression;
+    var functionExpression = expression as FunctionExpression;
     expect(functionExpression.parameters, isNotNull);
     expect(functionExpression.body, isNotNull);
   }
 
   void test_parsePrimaryExpression_function_noArguments() {
     Expression expression = parsePrimaryExpression('() => 42');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<FunctionExpression>());
-    FunctionExpression functionExpression = expression;
+    var functionExpression = expression as FunctionExpression;
     expect(functionExpression.parameters, isNotNull);
     expect(functionExpression.body, isNotNull);
   }
 
   void test_parsePrimaryExpression_genericFunctionExpression() {
     Expression expression =
         parsePrimaryExpression('<X, Y>(Map<X, Y> m, X x) => m[x]');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<FunctionExpression>());
-    FunctionExpression function = expression;
-    expect(function.typeParameters, isNotNull);
+    var functionExpression = expression as FunctionExpression;
+    expect(functionExpression.typeParameters, isNotNull);
   }
 
   void test_parsePrimaryExpression_hex() {
     String hexLiteral = "3F";
     Expression expression = parsePrimaryExpression('0x$hexLiteral');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<IntegerLiteral>());
-    IntegerLiteral literal = expression;
+    var literal = expression as IntegerLiteral;
     expect(literal.literal, isNotNull);
     expect(literal.value, int.parse(hexLiteral, radix: 16));
   }
 
   void test_parsePrimaryExpression_identifier() {
     Expression expression = parsePrimaryExpression('a');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleIdentifier>());
-    SimpleIdentifier identifier = expression;
+    var identifier = expression as SimpleIdentifier;
     expect(identifier, isNotNull);
   }
 
   void test_parsePrimaryExpression_int() {
     String intLiteral = "472";
     Expression expression = parsePrimaryExpression(intLiteral);
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<IntegerLiteral>());
-    IntegerLiteral literal = expression;
+    var literal = expression as IntegerLiteral;
     expect(literal.literal, isNotNull);
     expect(literal.value, int.parse(intLiteral));
   }
 
   void test_parsePrimaryExpression_listLiteral() {
     Expression expression = parsePrimaryExpression('[ ]');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<ListLiteral>());
-    ListLiteral literal = expression;
+    var literal = expression as ListLiteral;
     expect(literal, isNotNull);
   }
 
   void test_parsePrimaryExpression_listLiteral_index() {
     Expression expression = parsePrimaryExpression('[]');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<ListLiteral>());
-    ListLiteral literal = expression;
+    var literal = expression as ListLiteral;
     expect(literal, isNotNull);
   }
 
   void test_parsePrimaryExpression_listLiteral_typed() {
     Expression expression = parsePrimaryExpression('<A>[ ]');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<ListLiteral>());
-    ListLiteral literal = expression;
+    var literal = expression as ListLiteral;
     expect(literal.typeArguments, isNotNull);
     expect(literal.typeArguments.arguments, hasLength(1));
   }
 
   void test_parsePrimaryExpression_listLiteral_typed_genericComment() {
     enableGenericMethodComments = true;
     Expression expression = parsePrimaryExpression('/*<A>*/[ ]');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<ListLiteral>());
-    ListLiteral literal = expression;
+    var literal = expression as ListLiteral;
     expect(literal.typeArguments, isNotNull);
     expect(literal.typeArguments.arguments, hasLength(1));
   }
 
   void test_parsePrimaryExpression_mapLiteral() {
     Expression expression = parsePrimaryExpression('{}');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MapLiteral>());
-    MapLiteral literal = expression;
+    var literal = expression as MapLiteral;
     expect(literal.typeArguments, isNull);
     expect(literal, isNotNull);
   }
 
   void test_parsePrimaryExpression_mapLiteral_typed() {
     Expression expression = parsePrimaryExpression('<A, B>{}');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MapLiteral>());
-    MapLiteral literal = expression;
+    var literal = expression as MapLiteral;
     expect(literal.typeArguments, isNotNull);
     expect(literal.typeArguments.arguments, hasLength(2));
   }
 
   void test_parsePrimaryExpression_mapLiteral_typed_genericComment() {
     enableGenericMethodComments = true;
     Expression expression = parsePrimaryExpression('/*<A, B>*/{}');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<MapLiteral>());
-    MapLiteral literal = expression;
+    var literal = expression as MapLiteral;
     expect(literal.typeArguments, isNotNull);
     expect(literal.typeArguments.arguments, hasLength(2));
   }
 
   void test_parsePrimaryExpression_new() {
     Expression expression = parsePrimaryExpression('new A()');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<InstanceCreationExpression>());
-    InstanceCreationExpression creation = expression;
+    var creation = expression as InstanceCreationExpression;
     expect(creation, isNotNull);
   }
 
   void test_parsePrimaryExpression_null() {
     Expression expression = parsePrimaryExpression('null');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression, new isInstanceOf<NullLiteral>());
     NullLiteral literal = expression;
     expect(literal.literal, isNotNull);
   }
 
   void test_parsePrimaryExpression_parenthesized() {
     Expression expression = parsePrimaryExpression('(x)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<ParenthesizedExpression>());
-    ParenthesizedExpression parens = expression;
+    var parens = expression as ParenthesizedExpression;
     expect(parens, isNotNull);
   }
 
   void test_parsePrimaryExpression_string() {
     Expression expression = parsePrimaryExpression('"string"');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleStringLiteral>());
-    SimpleStringLiteral literal = expression;
+    var literal = expression as SimpleStringLiteral;
     expect(literal.isMultiline, isFalse);
     expect(literal.isRaw, isFalse);
     expect(literal.value, "string");
   }
 
   void test_parsePrimaryExpression_string_multiline() {
     Expression expression = parsePrimaryExpression("'''string'''");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleStringLiteral>());
-    SimpleStringLiteral literal = expression;
+    var literal = expression as SimpleStringLiteral;
     expect(literal.isMultiline, isTrue);
     expect(literal.isRaw, isFalse);
     expect(literal.value, "string");
   }
 
   void test_parsePrimaryExpression_string_raw() {
     Expression expression = parsePrimaryExpression("r'string'");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleStringLiteral>());
-    SimpleStringLiteral literal = expression;
+    var literal = expression as SimpleStringLiteral;
     expect(literal.isMultiline, isFalse);
     expect(literal.isRaw, isTrue);
     expect(literal.value, "string");
   }
 
   void test_parsePrimaryExpression_super() {
     Expression expression = parsePrimaryExpression('super.x');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<PropertyAccess>());
-    PropertyAccess propertyAccess = expression;
+    var propertyAccess = expression as PropertyAccess;
     expect(propertyAccess.target is SuperExpression, isTrue);
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.operator.type, TokenType.PERIOD);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parsePrimaryExpression_this() {
     Expression expression = parsePrimaryExpression('this');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<ThisExpression>());
-    ThisExpression thisExpression = expression;
+    var thisExpression = expression as ThisExpression;
     expect(thisExpression.thisKeyword, isNotNull);
   }
 
   void test_parsePrimaryExpression_true() {
     Expression expression = parsePrimaryExpression('true');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<BooleanLiteral>());
-    BooleanLiteral literal = expression;
+    var literal = expression as BooleanLiteral;
     expect(literal.literal, isNotNull);
     expect(literal.value, isTrue);
   }
 
   void test_parseRelationalExpression_as_functionType_noReturnType() {
     Expression expression = parseRelationalExpression('x as Function(int)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<AsExpression>());
-    AsExpression asExpression = expression;
+    var asExpression = expression as AsExpression;
     expect(asExpression.expression, isNotNull);
     expect(asExpression.asOperator, isNotNull);
     expect(asExpression.type, new isInstanceOf<GenericFunctionType>());
   }
 
   void test_parseRelationalExpression_as_functionType_returnType() {
     Expression expression =
         parseRelationalExpression('x as String Function(int)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<AsExpression>());
-    AsExpression asExpression = expression;
+    var asExpression = expression as AsExpression;
     expect(asExpression.expression, isNotNull);
     expect(asExpression.asOperator, isNotNull);
     expect(asExpression.type, new isInstanceOf<GenericFunctionType>());
   }
 
   void test_parseRelationalExpression_as_generic() {
     Expression expression = parseRelationalExpression('x as C<D>');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<AsExpression>());
-    AsExpression asExpression = expression;
+    var asExpression = expression as AsExpression;
     expect(asExpression.expression, isNotNull);
     expect(asExpression.asOperator, isNotNull);
     expect(asExpression.type, new isInstanceOf<TypeName>());
   }
 
   void test_parseRelationalExpression_as_nullable() {
     enableNnbd = true;
     Expression expression = parseRelationalExpression('x as Y?)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<AsExpression>());
-    AsExpression asExpression = expression;
+    var asExpression = expression as AsExpression;
     expect(asExpression.expression, isNotNull);
     expect(asExpression.asOperator, isNotNull);
     expect(asExpression.type, new isInstanceOf<TypeName>());
   }
 
   void test_parseRelationalExpression_as_simple() {
     Expression expression = parseRelationalExpression('x as Y');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<AsExpression>());
-    AsExpression asExpression = expression;
+    var asExpression = expression as AsExpression;
     expect(asExpression.expression, isNotNull);
     expect(asExpression.asOperator, isNotNull);
     expect(asExpression.type, new isInstanceOf<TypeName>());
   }
 
   void test_parseRelationalExpression_as_simple_function() {
     Expression expression = parseRelationalExpression('x as Function');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<AsExpression>());
-    AsExpression asExpression = expression;
+    var asExpression = expression as AsExpression;
     expect(asExpression.expression, isNotNull);
     expect(asExpression.asOperator, isNotNull);
     expect(asExpression.type, new isInstanceOf<TypeName>());
   }
 
   void test_parseRelationalExpression_is() {
     Expression expression = parseRelationalExpression('x is y');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<IsExpression>());
-    IsExpression isExpression = expression;
+    var isExpression = expression as IsExpression;
     expect(isExpression.expression, isNotNull);
     expect(isExpression.isOperator, isNotNull);
     expect(isExpression.notOperator, isNull);
     expect(isExpression.type, isNotNull);
   }
 
   void test_parseRelationalExpression_is_nullable() {
     enableNnbd = true;
     Expression expression = parseRelationalExpression('x is y?)');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<IsExpression>());
-    IsExpression isExpression = expression;
+    var isExpression = expression as IsExpression;
     expect(isExpression.expression, isNotNull);
     expect(isExpression.isOperator, isNotNull);
     expect(isExpression.notOperator, isNull);
     expect(isExpression.type, isNotNull);
   }
 
   void test_parseRelationalExpression_isNot() {
     Expression expression = parseRelationalExpression('x is! y');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<IsExpression>());
-    IsExpression isExpression = expression;
+    var isExpression = expression as IsExpression;
     expect(isExpression.expression, isNotNull);
     expect(isExpression.isOperator, isNotNull);
     expect(isExpression.notOperator, isNotNull);
     expect(isExpression.type, isNotNull);
   }
 
   void test_parseRelationalExpression_normal() {
     Expression expression = parseRelationalExpression('x < y');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<BinaryExpression>());
-    BinaryExpression binaryExpression = expression;
+    var binaryExpression = expression as BinaryExpression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.LT);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   void test_parseRelationalExpression_super() {
     Expression expression = parseRelationalExpression('super < y');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<BinaryExpression>());
-    BinaryExpression binaryExpression = expression;
+    var binaryExpression = expression as BinaryExpression;
     expect(binaryExpression.leftOperand, isNotNull);
     expect(binaryExpression.operator, isNotNull);
     expect(binaryExpression.operator.type, TokenType.LT);
     expect(binaryExpression.rightOperand, isNotNull);
   }
 
   void test_parseRethrowExpression() {
     RethrowExpression expression = parseRethrowExpression('rethrow');
     expect(expression, isNotNull);
     assertNoErrors();
@@ skipping 39 matching lines @@
     expect(identifier, isNotNull);
     assertNoErrors();
     expect(identifier.token, isNotNull);
     expect(identifier.name, lexeme);
   }
 
   void test_parseStringLiteral_adjacent() {
     Expression expression = parseStringLiteral("'a' 'b'");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<AdjacentStrings>());
-    AdjacentStrings literal = expression;
+    var literal = expression as AdjacentStrings;
     NodeList<StringLiteral> strings = literal.strings;
     expect(strings, hasLength(2));
     StringLiteral firstString = strings[0];
     StringLiteral secondString = strings[1];
     expect((firstString as SimpleStringLiteral).value, "a");
     expect((secondString as SimpleStringLiteral).value, "b");
   }
 
   void test_parseStringLiteral_endsWithInterpolation() {
     Expression expression = parseStringLiteral(r"'x$y'");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<StringInterpolation>());
-    StringInterpolation interpolation = expression;
+    var interpolation = expression as StringInterpolation;
     expect(interpolation.elements, hasLength(3));
     expect(interpolation.elements[0], new isInstanceOf<InterpolationString>());
     InterpolationString element0 = interpolation.elements[0];
     expect(element0.value, 'x');
     expect(
         interpolation.elements[1], new isInstanceOf<InterpolationExpression>());
     InterpolationExpression element1 = interpolation.elements[1];
     expect(element1.expression, new isInstanceOf<SimpleIdentifier>());
     expect(interpolation.elements[2], new isInstanceOf<InterpolationString>());
     InterpolationString element2 = interpolation.elements[2];
@@ skipping 12 matching lines @@
     expect(elements[1] is InterpolationExpression, isTrue);
     expect(elements[2] is InterpolationString, isTrue);
     expect(elements[3] is InterpolationExpression, isTrue);
     expect(elements[4] is InterpolationString, isTrue);
   }
 
   void test_parseStringLiteral_multiline_encodedSpace() {
     Expression expression = parseStringLiteral("'''\\x20\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleStringLiteral>());
-    SimpleStringLiteral literal = expression;
+    var literal = expression as SimpleStringLiteral;
     expect(literal.literal, isNotNull);
     expect(literal.value, " \na");
   }
 
   void test_parseStringLiteral_multiline_endsWithInterpolation() {
     Expression expression = parseStringLiteral(r"'''x$y'''");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<StringInterpolation>());
-    StringInterpolation interpolation = expression;
+    var interpolation = expression as StringInterpolation;
     expect(interpolation.elements, hasLength(3));
     expect(interpolation.elements[0], new isInstanceOf<InterpolationString>());
     InterpolationString element0 = interpolation.elements[0];
     expect(element0.value, 'x');
     expect(
         interpolation.elements[1], new isInstanceOf<InterpolationExpression>());
     InterpolationExpression element1 = interpolation.elements[1];
     expect(element1.expression, new isInstanceOf<SimpleIdentifier>());
     expect(interpolation.elements[2], new isInstanceOf<InterpolationString>());
     InterpolationString element2 = interpolation.elements[2];
     expect(element2.value, '');
   }
 
   void test_parseStringLiteral_multiline_escapedBackslash() {
     Expression expression = parseStringLiteral("'''\\\\\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleStringLiteral>());
-    SimpleStringLiteral literal = expression;
+    var literal = expression as SimpleStringLiteral;
     expect(literal.literal, isNotNull);
     expect(literal.value, "\\\na");
   }
 
   void test_parseStringLiteral_multiline_escapedBackslash_raw() {
     Expression expression = parseStringLiteral("r'''\\\\\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleStringLiteral>());
-    SimpleStringLiteral literal = expression;
+    var literal = expression as SimpleStringLiteral;
     expect(literal.literal, isNotNull);
     expect(literal.value, "\\\\\na");
   }
 
   void test_parseStringLiteral_multiline_escapedEolMarker() {
     Expression expression = parseStringLiteral("'''\\\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleStringLiteral>());
-    SimpleStringLiteral literal = expression;
+    var literal = expression as SimpleStringLiteral;
     expect(literal.literal, isNotNull);
     expect(literal.value, "a");
   }
 
   void test_parseStringLiteral_multiline_escapedEolMarker_raw() {
     Expression expression = parseStringLiteral("r'''\\\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleStringLiteral>());
-    SimpleStringLiteral literal = expression;
+    var literal = expression as SimpleStringLiteral;
     expect(literal.literal, isNotNull);
     expect(literal.value, "a");
   }
 
   void test_parseStringLiteral_multiline_escapedSpaceAndEolMarker() {
     Expression expression = parseStringLiteral("'''\\ \\\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleStringLiteral>());
-    SimpleStringLiteral literal = expression;
+    var literal = expression as SimpleStringLiteral;
     expect(literal.literal, isNotNull);
     expect(literal.value, "a");
   }
 
   void test_parseStringLiteral_multiline_escapedSpaceAndEolMarker_raw() {
     Expression expression = parseStringLiteral("r'''\\ \\\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleStringLiteral>());
-    SimpleStringLiteral literal = expression;
+    var literal = expression as SimpleStringLiteral;
     expect(literal.literal, isNotNull);
     expect(literal.value, "a");
   }
 
   void test_parseStringLiteral_multiline_escapedTab() {
     Expression expression = parseStringLiteral("'''\\t\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleStringLiteral>());
-    SimpleStringLiteral literal = expression;
+    var literal = expression as SimpleStringLiteral;
     expect(literal.literal, isNotNull);
     expect(literal.value, "\t\na");
   }
 
   void test_parseStringLiteral_multiline_escapedTab_raw() {
     Expression expression = parseStringLiteral("r'''\\t\na'''");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleStringLiteral>());
-    SimpleStringLiteral literal = expression;
+    var literal = expression as SimpleStringLiteral;
     expect(literal.literal, isNotNull);
     expect(literal.value, "\\t\na");
   }
 
   void test_parseStringLiteral_multiline_quoteAfterInterpolation() {
     Expression expression = parseStringLiteral(r"""'''$x'y'''""");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<StringInterpolation>());
-    StringInterpolation interpolation = expression;
+    var interpolation = expression as StringInterpolation;
     expect(interpolation.elements, hasLength(3));
     expect(interpolation.elements[0], new isInstanceOf<InterpolationString>());
     InterpolationString element0 = interpolation.elements[0];
     expect(element0.value, '');
     expect(
         interpolation.elements[1], new isInstanceOf<InterpolationExpression>());
     InterpolationExpression element1 = interpolation.elements[1];
     expect(element1.expression, new isInstanceOf<SimpleIdentifier>());
     expect(interpolation.elements[2], new isInstanceOf<InterpolationString>());
     InterpolationString element2 = interpolation.elements[2];
     expect(element2.value, "'y");
   }
 
   void test_parseStringLiteral_multiline_startsWithInterpolation() {
     Expression expression = parseStringLiteral(r"'''${x}y'''");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<StringInterpolation>());
-    StringInterpolation interpolation = expression;
+    var interpolation = expression as StringInterpolation;
     expect(interpolation.elements, hasLength(3));
     expect(interpolation.elements[0], new isInstanceOf<InterpolationString>());
     InterpolationString element0 = interpolation.elements[0];
     expect(element0.value, '');
     expect(
         interpolation.elements[1], new isInstanceOf<InterpolationExpression>());
     InterpolationExpression element1 = interpolation.elements[1];
     expect(element1.expression, new isInstanceOf<SimpleIdentifier>());
     expect(interpolation.elements[2], new isInstanceOf<InterpolationString>());
     InterpolationString element2 = interpolation.elements[2];
     expect(element2.value, 'y');
   }
 
   void test_parseStringLiteral_multiline_twoSpaces() {
     Expression expression = parseStringLiteral("'''  \na'''");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleStringLiteral>());
-    SimpleStringLiteral literal = expression;
+    var literal = expression as SimpleStringLiteral;
     expect(literal.literal, isNotNull);
     expect(literal.value, "a");
   }
 
   void test_parseStringLiteral_multiline_twoSpaces_raw() {
     Expression expression = parseStringLiteral("r'''  \na'''");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleStringLiteral>());
-    SimpleStringLiteral literal = expression;
+    var literal = expression as SimpleStringLiteral;
     expect(literal.literal, isNotNull);
     expect(literal.value, "a");
   }
 
   void test_parseStringLiteral_multiline_untrimmed() {
     Expression expression = parseStringLiteral("''' a\nb'''");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleStringLiteral>());
-    SimpleStringLiteral literal = expression;
+    var literal = expression as SimpleStringLiteral;
     expect(literal.literal, isNotNull);
     expect(literal.value, " a\nb");
   }
 
   void test_parseStringLiteral_quoteAfterInterpolation() {
     Expression expression = parseStringLiteral(r"""'$x"'""");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<StringInterpolation>());
-    StringInterpolation interpolation = expression;
+    var interpolation = expression as StringInterpolation;
     expect(interpolation.elements, hasLength(3));
     expect(interpolation.elements[0], new isInstanceOf<InterpolationString>());
     InterpolationString element0 = interpolation.elements[0];
     expect(element0.value, '');
     expect(
         interpolation.elements[1], new isInstanceOf<InterpolationExpression>());
     InterpolationExpression element1 = interpolation.elements[1];
     expect(element1.expression, new isInstanceOf<SimpleIdentifier>());
     expect(interpolation.elements[2], new isInstanceOf<InterpolationString>());
     InterpolationString element2 = interpolation.elements[2];
     expect(element2.value, '"');
   }
 
   void test_parseStringLiteral_single() {
     Expression expression = parseStringLiteral("'a'");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleStringLiteral>());
-    SimpleStringLiteral literal = expression;
+    var literal = expression as SimpleStringLiteral;
     expect(literal.literal, isNotNull);
     expect(literal.value, "a");
   }
 
   void test_parseStringLiteral_startsWithInterpolation() {
     Expression expression = parseStringLiteral(r"'${x}y'");
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<StringInterpolation>());
-    StringInterpolation interpolation = expression;
+    var interpolation = expression as StringInterpolation;
     expect(interpolation.elements, hasLength(3));
     expect(interpolation.elements[0], new isInstanceOf<InterpolationString>());
     InterpolationString element0 = interpolation.elements[0];
     expect(element0.value, '');
     expect(
         interpolation.elements[1], new isInstanceOf<InterpolationExpression>());
     InterpolationExpression element1 = interpolation.elements[1];
     expect(element1.expression, new isInstanceOf<SimpleIdentifier>());
     expect(interpolation.elements[2], new isInstanceOf<InterpolationString>());
     InterpolationString element2 = interpolation.elements[2];
@@ skipping 73 matching lines @@
     expect(literal.poundSign, isNotNull);
     List<Token> components = literal.components;
     expect(components, hasLength(1));
     expect(components[0].lexeme, "void");
   }
 
   void test_parseThrowExpression() {
     Expression expression = parseThrowExpression('throw x');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<ThrowExpression>());
-    ThrowExpression throwExpression = expression;
+    var throwExpression = expression as ThrowExpression;
     expect(throwExpression.throwKeyword, isNotNull);
     expect(throwExpression.expression, isNotNull);
   }
 
   void test_parseThrowExpressionWithoutCascade() {
     Expression expression = parseThrowExpressionWithoutCascade('throw x');
     expect(expression, isNotNull);
     assertNoErrors();
-    expect(expression, new isInstanceOf<ThrowExpression>());
-    ThrowExpression throwExpression = expression;
+    var throwExpression = expression as ThrowExpression;
     expect(throwExpression.throwKeyword, isNotNull);
     expect(throwExpression.expression, isNotNull);
   }
 
   void test_parseUnaryExpression_decrement_normal() {
     PrefixExpression expression = parseUnaryExpression('--x');
     expect(expression, isNotNull);
     assertNoErrors();
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.MINUS_MINUS);
@@ skipping 3410 matching lines @@
     expect(name.colon, isNotNull);
     expect(namedExpression.expression, isNotNull);
   }
 
   void test_parseArgument_unnamed() {
     String lexeme = "x";
     createParser(lexeme);
     Expression expression = parser.parseArgument();
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
-    expect(expression, new isInstanceOf<SimpleIdentifier>());
-    SimpleIdentifier identifier = expression;
+    var identifier = expression as SimpleIdentifier;
     expect(identifier.name, lexeme);
   }
 
   void test_parseArgumentList_empty() {
     createParser('()');
     ArgumentList argumentList = parser.parseArgumentList();
     expectNotNullIfNoErrors(argumentList);
     listener.assertNoErrors();
     NodeList<Expression> arguments = argumentList.arguments;
     expect(arguments, hasLength(0));
@@ skipping 4823 matching lines @@
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.typeParameters, isNull);
     expect(typeAlias.semicolon, isNotNull);
     GenericFunctionType functionType = typeAlias.functionType;
     expect(functionType, isNotNull);
     expect(functionType.parameters, isNotNull);
     expect(functionType.returnType, isNotNull);
     expect(functionType.typeParameters, isNull);
   }
 }