New analyzer_experimental snapshot.

pkg/analyzer_experimental/test/generated/parser_test.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.parser_test;
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
 import 'package:analyzer_experimental/src/generated/ast.dart';
 import 'package:analyzer_experimental/src/generated/parser.dart';
 import 'package:analyzer_experimental/src/generated/utilities_dart.dart';
@@ skipping 624 matching lines @@
     JUnitTestCase.assertNull(declaration.abstractKeyword);
     JUnitTestCase.assertNull(declaration.extendsClause);
     JUnitTestCase.assertNull(declaration.implementsClause);
     JUnitTestCase.assertNotNull(declaration.classKeyword);
     JUnitTestCase.assertNotNull(declaration.leftBracket);
     JUnitTestCase.assertNotNull(declaration.name);
     EngineTestCase.assertSize(1, declaration.members);
     JUnitTestCase.assertNotNull(declaration.rightBracket);
     JUnitTestCase.assertNull(declaration.typeParameters);
   }
+  void test_parseClassDeclaration_typeAlias_implementsC() {
+    ClassTypeAlias typeAlias = ParserTestCase.parse("parseClassDeclaration", <Object> [emptyCommentAndMetadata(), null], "class A = Object with B implements C;");
+    JUnitTestCase.assertNotNull(typeAlias.keyword);
+    JUnitTestCase.assertNotNull(typeAlias.name);
+    JUnitTestCase.assertNull(typeAlias.typeParameters);
+    JUnitTestCase.assertNotNull(typeAlias.withClause);
+    JUnitTestCase.assertNotNull(typeAlias.implementsClause);
+    JUnitTestCase.assertNotNull(typeAlias.implementsClause.keyword);
+    JUnitTestCase.assertEquals(1, typeAlias.implementsClause.interfaces.length);
+    JUnitTestCase.assertNotNull(typeAlias.semicolon);
+  }
+  void test_parseClassDeclaration_typeAlias_withB() {
+    ClassTypeAlias typeAlias = ParserTestCase.parse("parseClassDeclaration", <Object> [emptyCommentAndMetadata(), null], "class A = Object with B;");
+    JUnitTestCase.assertNotNull(typeAlias.keyword);
+    JUnitTestCase.assertNotNull(typeAlias.name);
+    JUnitTestCase.assertNull(typeAlias.typeParameters);
+    JUnitTestCase.assertNotNull(typeAlias.withClause);
+    JUnitTestCase.assertNotNull(typeAlias.withClause.withKeyword);
+    JUnitTestCase.assertEquals(1, typeAlias.withClause.mixinTypes.length);
+    JUnitTestCase.assertNull(typeAlias.implementsClause);
+    JUnitTestCase.assertNotNull(typeAlias.semicolon);
+  }
   void test_parseClassDeclaration_typeParameters() {
     ClassDeclaration declaration = ParserTestCase.parse("parseClassDeclaration", <Object> [emptyCommentAndMetadata(), null], "class A<B> {}");
     JUnitTestCase.assertNull(declaration.documentationComment);
     JUnitTestCase.assertNull(declaration.abstractKeyword);
     JUnitTestCase.assertNull(declaration.extendsClause);
     JUnitTestCase.assertNull(declaration.implementsClause);
     JUnitTestCase.assertNotNull(declaration.classKeyword);
     JUnitTestCase.assertNotNull(declaration.leftBracket);
     JUnitTestCase.assertNotNull(declaration.name);
     EngineTestCase.assertSize(0, declaration.members);
@@ skipping 263 matching lines @@
     JUnitTestCase.assertNotNull(constructor.returnType);
     JUnitTestCase.assertNull(constructor.period);
     JUnitTestCase.assertNull(constructor.name);
     JUnitTestCase.assertNotNull(constructor.parameters);
     JUnitTestCase.assertNotNull(constructor.separator);
     EngineTestCase.assertSize(0, constructor.initializers);
     JUnitTestCase.assertNotNull(constructor.redirectedConstructor);
     JUnitTestCase.assertNotNull(constructor.body);
   }
   void test_parseClassTypeAlias() {
-    Token token = TokenFactory.token(Keyword.TYPEDEF);
+    Token token = TokenFactory.token(Keyword.CLASS);
     ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token], "A = B;");
     JUnitTestCase.assertNotNull(classTypeAlias.keyword);
     JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.equals);
     JUnitTestCase.assertNull(classTypeAlias.abstractKeyword);
     JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
     JUnitTestCase.assertNull(classTypeAlias.withClause);
     JUnitTestCase.assertNull(classTypeAlias.implementsClause);
     JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
   }
   void test_parseClassTypeAlias_abstract() {
-    Token token = TokenFactory.token(Keyword.TYPEDEF);
+    Token token = TokenFactory.token(Keyword.CLASS);
     ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token], "A = abstract B;");
     JUnitTestCase.assertNotNull(classTypeAlias.keyword);
     JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.equals);
     JUnitTestCase.assertNotNull(classTypeAlias.abstractKeyword);
     JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
     JUnitTestCase.assertNull(classTypeAlias.withClause);
     JUnitTestCase.assertNull(classTypeAlias.implementsClause);
     JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
   }
   void test_parseClassTypeAlias_implements() {
-    Token token = TokenFactory.token(Keyword.TYPEDEF);
+    Token token = TokenFactory.token(Keyword.CLASS);
     ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token], "A = B implements C;");
     JUnitTestCase.assertNotNull(classTypeAlias.keyword);
     JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.equals);
     JUnitTestCase.assertNull(classTypeAlias.abstractKeyword);
     JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
     JUnitTestCase.assertNull(classTypeAlias.withClause);
     JUnitTestCase.assertNotNull(classTypeAlias.implementsClause);
     JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
   }
   void test_parseClassTypeAlias_with() {
-    Token token = TokenFactory.token(Keyword.TYPEDEF);
+    Token token = TokenFactory.token(Keyword.CLASS);
     ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token], "A = B with C;");
     JUnitTestCase.assertNotNull(classTypeAlias.keyword);
     JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.equals);
     JUnitTestCase.assertNull(classTypeAlias.abstractKeyword);
     JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.withClause);
     JUnitTestCase.assertNull(classTypeAlias.implementsClause);
     JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
   }
   void test_parseClassTypeAlias_with_implements() {
-    Token token = TokenFactory.token(Keyword.TYPEDEF);
+    Token token = TokenFactory.token(Keyword.CLASS);
     ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token], "A = B with C implements D;");
     JUnitTestCase.assertNotNull(classTypeAlias.keyword);
     JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.equals);
     JUnitTestCase.assertNull(classTypeAlias.abstractKeyword);
     JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.withClause);
     JUnitTestCase.assertNotNull(classTypeAlias.implementsClause);
     JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
   }
@@ skipping 339 matching lines @@
   void test_parseCompilationUnitMember_setter_noType() {
     FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "set p(v) {}");
     JUnitTestCase.assertNotNull(declaration.functionExpression);
     JUnitTestCase.assertNotNull(declaration.propertyKeyword);
   }
   void test_parseCompilationUnitMember_setter_type() {
     FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "void set p(int v) {}");
     JUnitTestCase.assertNotNull(declaration.functionExpression);
     JUnitTestCase.assertNotNull(declaration.propertyKeyword);
   }
-  void test_parseCompilationUnitMember_typedef_class_abstract() {
-    ClassTypeAlias typeAlias = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "typedef C = abstract S with M;");
+  void test_parseCompilationUnitMember_typeAlias_abstract() {
+    ClassTypeAlias typeAlias = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "class C = abstract S with M;");
     JUnitTestCase.assertNotNull(typeAlias.keyword);
     JUnitTestCase.assertEquals("C", typeAlias.name.name);
     JUnitTestCase.assertNull(typeAlias.typeParameters);
     JUnitTestCase.assertNotNull(typeAlias.equals);
     JUnitTestCase.assertNotNull(typeAlias.abstractKeyword);
     JUnitTestCase.assertEquals("S", typeAlias.superclass.name.name);
     JUnitTestCase.assertNotNull(typeAlias.withClause);
     JUnitTestCase.assertNull(typeAlias.implementsClause);
     JUnitTestCase.assertNotNull(typeAlias.semicolon);
   }
-  void test_parseCompilationUnitMember_typedef_class_generic() {
-    ClassTypeAlias typeAlias = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "typedef C<E> = S<E> with M<E> implements I<E>;");
+  void test_parseCompilationUnitMember_typeAlias_generic() {
+    ClassTypeAlias typeAlias = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "class C<E> = S<E> with M<E> implements I<E>;");
     JUnitTestCase.assertNotNull(typeAlias.keyword);
     JUnitTestCase.assertEquals("C", typeAlias.name.name);
     EngineTestCase.assertSize(1, typeAlias.typeParameters.typeParameters);
     JUnitTestCase.assertNotNull(typeAlias.equals);
     JUnitTestCase.assertNull(typeAlias.abstractKeyword);
     JUnitTestCase.assertEquals("S", typeAlias.superclass.name.name);
     JUnitTestCase.assertNotNull(typeAlias.withClause);
     JUnitTestCase.assertNotNull(typeAlias.implementsClause);
     JUnitTestCase.assertNotNull(typeAlias.semicolon);
   }
-  void test_parseCompilationUnitMember_typedef_class_implements() {
-    ClassTypeAlias typeAlias = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "typedef C = S with M implements I;");
+  void test_parseCompilationUnitMember_typeAlias_implements() {
+    ClassTypeAlias typeAlias = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "class C = S with M implements I;");
     JUnitTestCase.assertNotNull(typeAlias.keyword);
     JUnitTestCase.assertEquals("C", typeAlias.name.name);
     JUnitTestCase.assertNull(typeAlias.typeParameters);
     JUnitTestCase.assertNotNull(typeAlias.equals);
     JUnitTestCase.assertNull(typeAlias.abstractKeyword);
     JUnitTestCase.assertEquals("S", typeAlias.superclass.name.name);
     JUnitTestCase.assertNotNull(typeAlias.withClause);
     JUnitTestCase.assertNotNull(typeAlias.implementsClause);
     JUnitTestCase.assertNotNull(typeAlias.semicolon);
   }
-  void test_parseCompilationUnitMember_typedef_class_noImplements() {
-    ClassTypeAlias typeAlias = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "typedef C = S with M;");
+  void test_parseCompilationUnitMember_typeAlias_noImplements() {
+    ClassTypeAlias typeAlias = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "class C = S with M;");
     JUnitTestCase.assertNotNull(typeAlias.keyword);
     JUnitTestCase.assertEquals("C", typeAlias.name.name);
     JUnitTestCase.assertNull(typeAlias.typeParameters);
     JUnitTestCase.assertNotNull(typeAlias.equals);
     JUnitTestCase.assertNull(typeAlias.abstractKeyword);
     JUnitTestCase.assertEquals("S", typeAlias.superclass.name.name);
     JUnitTestCase.assertNotNull(typeAlias.withClause);
     JUnitTestCase.assertNull(typeAlias.implementsClause);
     JUnitTestCase.assertNotNull(typeAlias.semicolon);
   }
-  void test_parseCompilationUnitMember_typedef_function() {
+  void test_parseCompilationUnitMember_typedef() {
     FunctionTypeAlias typeAlias = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "typedef F();");
     JUnitTestCase.assertEquals("F", typeAlias.name.name);
     EngineTestCase.assertSize(0, typeAlias.parameters.parameters);
   }
   void test_parseCompilationUnitMember_variable() {
     TopLevelVariableDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "var x = 0;");
     JUnitTestCase.assertNotNull(declaration.semicolon);
     JUnitTestCase.assertNotNull(declaration.variables);
   }
   void test_parseCompilationUnitMember_variableGet() {
@@ skipping 1948 matching lines @@
     JUnitTestCase.assertNotNull(clause.onKeyword);
     JUnitTestCase.assertNotNull(clause.exceptionType);
     JUnitTestCase.assertNotNull(clause.catchKeyword);
     JUnitTestCase.assertNotNull(clause.exceptionParameter);
     JUnitTestCase.assertNotNull(clause.comma);
     JUnitTestCase.assertNotNull(clause.stackTraceParameter);
     JUnitTestCase.assertNotNull(clause.body);
     JUnitTestCase.assertNotNull(statement.finallyKeyword);
     JUnitTestCase.assertNotNull(statement.finallyBlock);
   }
-  void test_parseTypeAlias_class_implementsC() {
-    ClassTypeAlias typeAlias = ParserTestCase.parse("parseTypeAlias", <Object> [emptyCommentAndMetadata()], "typedef A = Object with B implements C;");
-    JUnitTestCase.assertNotNull(typeAlias.keyword);
-    JUnitTestCase.assertNotNull(typeAlias.name);
-    JUnitTestCase.assertNull(typeAlias.typeParameters);
-    JUnitTestCase.assertNotNull(typeAlias.withClause);
-    JUnitTestCase.assertNotNull(typeAlias.implementsClause);
-    JUnitTestCase.assertNotNull(typeAlias.implementsClause.keyword);
-    JUnitTestCase.assertEquals(1, typeAlias.implementsClause.interfaces.length);
-    JUnitTestCase.assertNotNull(typeAlias.semicolon);
-  }
-  void test_parseTypeAlias_class_withB() {
-    ClassTypeAlias typeAlias = ParserTestCase.parse("parseTypeAlias", <Object> [emptyCommentAndMetadata()], "typedef A = Object with B;");
-    JUnitTestCase.assertNotNull(typeAlias.keyword);
-    JUnitTestCase.assertNotNull(typeAlias.name);
-    JUnitTestCase.assertNull(typeAlias.typeParameters);
-    JUnitTestCase.assertNotNull(typeAlias.withClause);
-    JUnitTestCase.assertNotNull(typeAlias.withClause.withKeyword);
-    JUnitTestCase.assertEquals(1, typeAlias.withClause.mixinTypes.length);
-    JUnitTestCase.assertNull(typeAlias.implementsClause);
-    JUnitTestCase.assertNotNull(typeAlias.semicolon);
-  }
   void test_parseTypeAlias_function_noParameters() {
     FunctionTypeAlias typeAlias = ParserTestCase.parse("parseTypeAlias", <Object> [emptyCommentAndMetadata()], "typedef bool F();");
     JUnitTestCase.assertNotNull(typeAlias.keyword);
     JUnitTestCase.assertNotNull(typeAlias.name);
     JUnitTestCase.assertNotNull(typeAlias.parameters);
     JUnitTestCase.assertNotNull(typeAlias.returnType);
     JUnitTestCase.assertNotNull(typeAlias.semicolon);
     JUnitTestCase.assertNull(typeAlias.typeParameters);
   }
   void test_parseTypeAlias_function_noReturnType() {
@@ skipping 973 matching lines @@
         runJUnitTest(__test, __test.test_parseClassDeclaration_implements);
       });
       _ut.test('test_parseClassDeclaration_native', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseClassDeclaration_native);
       });
       _ut.test('test_parseClassDeclaration_nonEmpty', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseClassDeclaration_nonEmpty);
       });
+      _ut.test('test_parseClassDeclaration_typeAlias_implementsC', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseClassDeclaration_typeAlias_implementsC);
+      });
+      _ut.test('test_parseClassDeclaration_typeAlias_withB', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseClassDeclaration_typeAlias_withB);
+      });
       _ut.test('test_parseClassDeclaration_typeParameters', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseClassDeclaration_typeParameters);
       });
       _ut.test('test_parseClassMember_constructor_withInitializers', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseClassMember_constructor_withInitializers);
       });
       _ut.test('test_parseClassMember_field_instance_prefixedType', () {
         final __test = new SimpleParserTest();
@@ skipping 260 matching lines @@
         runJUnitTest(__test, __test.test_parseCompilationUnitMember_setter_external_type);
       });
       _ut.test('test_parseCompilationUnitMember_setter_noType', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseCompilationUnitMember_setter_noType);
       });
       _ut.test('test_parseCompilationUnitMember_setter_type', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseCompilationUnitMember_setter_type);
       });
-      _ut.test('test_parseCompilationUnitMember_typedef_class_abstract', () {
+      _ut.test('test_parseCompilationUnitMember_typeAlias_abstract', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseCompilationUnitMember_typedef_class_abstract);
+        runJUnitTest(__test, __test.test_parseCompilationUnitMember_typeAlias_abstract);
       });
-      _ut.test('test_parseCompilationUnitMember_typedef_class_generic', () {
+      _ut.test('test_parseCompilationUnitMember_typeAlias_generic', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseCompilationUnitMember_typedef_class_generic);
+        runJUnitTest(__test, __test.test_parseCompilationUnitMember_typeAlias_generic);
       });
-      _ut.test('test_parseCompilationUnitMember_typedef_class_implements', () {
+      _ut.test('test_parseCompilationUnitMember_typeAlias_implements', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseCompilationUnitMember_typedef_class_implements);
+        runJUnitTest(__test, __test.test_parseCompilationUnitMember_typeAlias_implements);
       });
-      _ut.test('test_parseCompilationUnitMember_typedef_class_noImplements', () {
+      _ut.test('test_parseCompilationUnitMember_typeAlias_noImplements', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseCompilationUnitMember_typedef_class_noImplements);
+        runJUnitTest(__test, __test.test_parseCompilationUnitMember_typeAlias_noImplements);
       });
-      _ut.test('test_parseCompilationUnitMember_typedef_function', () {
+      _ut.test('test_parseCompilationUnitMember_typedef', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseCompilationUnitMember_typedef_function);
+        runJUnitTest(__test, __test.test_parseCompilationUnitMember_typedef);
       });
       _ut.test('test_parseCompilationUnitMember_variable', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseCompilationUnitMember_variable);
       });
       _ut.test('test_parseCompilationUnitMember_variableGet', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseCompilationUnitMember_variableGet);
       });
       _ut.test('test_parseCompilationUnitMember_variableSet', () {
@@ skipping 1065 matching lines @@
         runJUnitTest(__test, __test.test_parseTryStatement_on);
       });
       _ut.test('test_parseTryStatement_on_catch', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseTryStatement_on_catch);
       });
       _ut.test('test_parseTryStatement_on_catch_finally', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseTryStatement_on_catch_finally);
       });
-      _ut.test('test_parseTypeAlias_class_implementsC', () {
-        final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseTypeAlias_class_implementsC);
-      });
-      _ut.test('test_parseTypeAlias_class_withB', () {
-        final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseTypeAlias_class_withB);
-      });
       _ut.test('test_parseTypeAlias_function_noParameters', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseTypeAlias_function_noParameters);
       });
       _ut.test('test_parseTypeAlias_function_noReturnType', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseTypeAlias_function_noReturnType);
       });
       _ut.test('test_parseTypeAlias_function_parameterizedReturnType', () {
         final __test = new SimpleParserTest();
@@ skipping 674 matching lines @@
         final __test = new ComplexParserTest();
         runJUnitTest(__test, __test.test_topLevelVariable_withMetadata);
       });
     });
   }
 }
 /**
  * Instances of the class `ASTValidator` are used to validate the correct construction of an
  * AST structure.
  */
-class ASTValidator extends GeneralizingASTVisitor<Object> {
+class ASTValidator extends UnifyingASTVisitor<Object> {
 
   /**
    * A list containing the errors found while traversing the AST structure.
    */
   List<String> _errors = new List<String>();
 
   /**
    * Assert that no errors were found while traversing any of the AST structures that have been
    * visited.
    */
@@ skipping 508 matching lines @@
         ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
   }
   void test_bitwiseXorExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super ^  ^", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
   }
   void test_classTypeAlias_withBody() {
-    ParserTestCase.parseCompilationUnit(EngineTestCase.createSource(["class A {}", "typedef B = Object with A {}"]), [ParserErrorCode.EXPECTED_TOKEN]);
+    ParserTestCase.parseCompilationUnit(EngineTestCase.createSource(["class A {}", "class B = Object with A {}"]), [ParserErrorCode.EXPECTED_TOKEN]);
   }
   void test_conditionalExpression_missingElse() {
     ConditionalExpression expression = ParserTestCase.parse5("parseConditionalExpression", "x ? y :", [ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.elseExpression);
     JUnitTestCase.assertTrue(expression.elseExpression.isSynthetic);
   }
   void test_conditionalExpression_missingThen() {
     ConditionalExpression expression = ParserTestCase.parse5("parseConditionalExpression", "x ? : z", [ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.thenExpression);
     JUnitTestCase.assertTrue(expression.thenExpression.isSynthetic);
@@ skipping 598 matching lines @@
         runJUnitTest(__test, __test.test_typedef_eof);
       });
     });
   }
 }
 /**
  * The class `ErrorParserTest` defines parser tests that test the parsing of code to ensure
  * that errors are correctly reported, and in some cases, not reported.
  */
 class ErrorParserTest extends ParserTestCase {
+  void fail_deprecatedClassTypeAlias() {
+    ParserTestCase.parseCompilationUnit("typedef C = abstract S with M;", [ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS]);
+  }
+  void fail_deprecatedClassTypeAlias_withGeneric() {
+    ParserTestCase.parseCompilationUnit("typedef C<T> = abstract S<T> with M;", [ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS]);
+  }
   void fail_expectedListOrMapLiteral() {
     TypedLiteral literal = ParserTestCase.parse4("parseListOrMapLiteral", <Object> [null], "1", [ParserErrorCode.EXPECTED_LIST_OR_MAP_LITERAL]);
     JUnitTestCase.assertTrue(literal.isSynthetic);
   }
   void fail_illegalAssignmentToNonAssignable_superAssigned() {
     ParserTestCase.parseExpression("super = x;", [ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE]);
   }
   void fail_invalidCommentReference__new_nonIdentifier() {
     ParserTestCase.parse4("parseCommentReference", <Object> ["new 42", 0], "", [ParserErrorCode.INVALID_COMMENT_REFERENCE]);
   }
@@ skipping 203 matching lines @@
   }
   void test_expectedExecutable_topLevel_afterVoid() {
     ParserTestCase.parse4("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "void 2 void", [ParserErrorCode.EXPECTED_EXECUTABLE]);
   }
   void test_expectedExecutable_topLevel_beforeType() {
     ParserTestCase.parse4("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "4 score", [ParserErrorCode.EXPECTED_EXECUTABLE]);
   }
   void test_expectedInterpolationIdentifier() {
     ParserTestCase.parse5("parseStringLiteral", "'\$x\$'", [ParserErrorCode.MISSING_IDENTIFIER]);
   }
-  void test_expectedOneListTypeArguments_two() {
-    Expression expression = ParserTestCase.parse5("parsePrimaryExpression", "<int, int>[]", [ParserErrorCode.EXPECTED_ONE_LIST_TYPE_ARGUMENTS]);
-    EngineTestCase.assertInstanceOf(ListLiteral, expression);
-  }
   void test_expectedStringLiteral() {
     StringLiteral expression = ParserTestCase.parse5("parseStringLiteral", "1", [ParserErrorCode.EXPECTED_STRING_LITERAL]);
     JUnitTestCase.assertTrue(expression.isSynthetic);
   }
   void test_expectedToken_commaMissingInArgumentList() {
     ParserTestCase.parse5("parseArgumentList", "(x, y z)", [ParserErrorCode.EXPECTED_TOKEN]);
   }
   void test_expectedToken_parseStatement_afterVoid() {
     ParserTestCase.parseStatement("void}", [
         ParserErrorCode.EXPECTED_TOKEN,
         ParserErrorCode.MISSING_IDENTIFIER]);
   }
-  void test_expectedToken_semicolonAfterTypedef() {
-    Token token = TokenFactory.token(Keyword.TYPEDEF);
+  void test_expectedToken_semicolonAfterClass() {
+    Token token = TokenFactory.token(Keyword.CLASS);
     ParserTestCase.parse4("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token], "A = B", [ParserErrorCode.EXPECTED_TOKEN]);
   }
   void test_expectedToken_semicolonMissingAfterExpression() {
     ParserTestCase.parseStatement("x", [ParserErrorCode.EXPECTED_TOKEN]);
   }
   void test_expectedToken_whileMissingInDoStatement() {
     ParserTestCase.parseStatement("do {} (x);", [ParserErrorCode.EXPECTED_TOKEN]);
   }
-  void test_expectedTwoMapTypeArguments_one() {
-    Expression expression = ParserTestCase.parse5("parsePrimaryExpression", "<int>{}", [ParserErrorCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS]);
-    EngineTestCase.assertInstanceOf(MapLiteral, expression);
-  }
-  void test_expectedTwoMapTypeArguments_three() {
-    Expression expression = ParserTestCase.parse5("parsePrimaryExpression", "<int, int, int>{}", [ParserErrorCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS]);
-    EngineTestCase.assertInstanceOf(MapLiteral, expression);
-  }
   void test_expectedTypeName_is() {
     ParserTestCase.parseExpression("x is", [ParserErrorCode.EXPECTED_TYPE_NAME]);
   }
   void test_exportDirectiveAfterPartDirective() {
     ParserTestCase.parseCompilationUnit("part 'a.dart'; export 'b.dart';", [ParserErrorCode.EXPORT_DIRECTIVE_AFTER_PART_DIRECTIVE]);
   }
   void test_externalAfterConst() {
     ParserTestCase.parse4("parseClassMember", <Object> ["C"], "const external C();", [ParserErrorCode.EXTERNAL_AFTER_CONST]);
   }
   void test_externalAfterFactory() {
@@ skipping 759 matching lines @@
         runJUnitTest(__test, __test.test_expectedExecutable_topLevel_afterVoid);
       });
       _ut.test('test_expectedExecutable_topLevel_beforeType', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedExecutable_topLevel_beforeType);
       });
       _ut.test('test_expectedInterpolationIdentifier', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedInterpolationIdentifier);
       });
-      _ut.test('test_expectedOneListTypeArguments_two', () {
-        final __test = new ErrorParserTest();
-        runJUnitTest(__test, __test.test_expectedOneListTypeArguments_two);
-      });
       _ut.test('test_expectedStringLiteral', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedStringLiteral);
       });
       _ut.test('test_expectedToken_commaMissingInArgumentList', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedToken_commaMissingInArgumentList);
       });
       _ut.test('test_expectedToken_parseStatement_afterVoid', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedToken_parseStatement_afterVoid);
       });
-      _ut.test('test_expectedToken_semicolonAfterTypedef', () {
+      _ut.test('test_expectedToken_semicolonAfterClass', () {
         final __test = new ErrorParserTest();
-        runJUnitTest(__test, __test.test_expectedToken_semicolonAfterTypedef);
+        runJUnitTest(__test, __test.test_expectedToken_semicolonAfterClass);
       });
       _ut.test('test_expectedToken_semicolonMissingAfterExpression', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedToken_semicolonMissingAfterExpression);
       });
       _ut.test('test_expectedToken_whileMissingInDoStatement', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedToken_whileMissingInDoStatement);
       });
-      _ut.test('test_expectedTwoMapTypeArguments_one', () {
-        final __test = new ErrorParserTest();
-        runJUnitTest(__test, __test.test_expectedTwoMapTypeArguments_one);
-      });
-      _ut.test('test_expectedTwoMapTypeArguments_three', () {
-        final __test = new ErrorParserTest();
-        runJUnitTest(__test, __test.test_expectedTwoMapTypeArguments_three);
-      });
       _ut.test('test_expectedTypeName_is', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedTypeName_is);
       });
       _ut.test('test_exportDirectiveAfterPartDirective', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_exportDirectiveAfterPartDirective);
       });
       _ut.test('test_externalAfterConst', () {
         final __test = new ErrorParserTest();
@@ skipping 850 matching lines @@
   'validateModifiersForTopLevelFunction_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTopLevelFunction(arg0)),
   'validateModifiersForTopLevelVariable_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTopLevelVariable(arg0)),
   'validateModifiersForTypedef_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTypedef(arg0)),};
 
 
 Object invokeParserMethodImpl(Parser parser, String methodName, List<Object> objects, Token tokenStream) {
   parser.currentToken = tokenStream;
   MethodTrampoline method = _methodTable_Parser['${methodName}_${objects.length}'];
   return method.invoke(parser, objects);
 }