New analyzer snapshot.

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.
 
 // 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/src/generated/java_core.dart';
@@ skipping 116 matching lines @@
   void test_createSyntheticIdentifier() {
     SimpleIdentifier identifier = _createSyntheticIdentifier();
     JUnitTestCase.assertTrue(identifier.isSynthetic);
   }
 
   void test_createSyntheticStringLiteral() {
     SimpleStringLiteral literal = _createSyntheticStringLiteral();
     JUnitTestCase.assertTrue(literal.isSynthetic);
   }
 
+  void test_function_literal_allowed_at_toplevel() {
+    ParserTestCase.parseCompilationUnit("var x = () {};", []);
+  }
+
+  void test_function_literal_allowed_in_ArgumentList_in_ConstructorFieldInitializer() {
+    ParserTestCase.parseCompilationUnit("class C { C() : a = f(() {}); }", []);
+  }
+
+  void test_function_literal_allowed_in_IndexExpression_in_ConstructorFieldInitializer() {
+    ParserTestCase.parseCompilationUnit("class C { C() : a = x[() {}]; }", []);
+  }
+
+  void test_function_literal_allowed_in_ListLiteral_in_ConstructorFieldInitializer() {
+    ParserTestCase.parseCompilationUnit("class C { C() : a = [() {}]; }", []);
+  }
+
+  void test_function_literal_allowed_in_MapLiteral_in_ConstructorFieldInitializer() {
+    ParserTestCase.parseCompilationUnit("class C { C() : a = {'key': () {}}; }", []);
+  }
+
+  void test_function_literal_allowed_in_ParenthesizedExpression_in_ConstructorFieldInitializer() {
+    ParserTestCase.parseCompilationUnit("class C { C() : a = (() {}); }", []);
+  }
+
+  void test_function_literal_allowed_in_StringInterpolation_in_ConstructorFieldInitializer() {
+    ParserTestCase.parseCompilationUnit("class C { C() : a = \"\${(){}}\"; }", []);
+  }
+
   void test_isFunctionDeclaration_nameButNoReturn_block() {
     JUnitTestCase.assertTrue(_isFunctionDeclaration("f() {}"));
   }
 
   void test_isFunctionDeclaration_nameButNoReturn_expression() {
     JUnitTestCase.assertTrue(_isFunctionDeclaration("f() => e"));
   }
 
   void test_isFunctionDeclaration_normalReturn_block() {
     JUnitTestCase.assertTrue(_isFunctionDeclaration("C f() {}"));
@@ skipping 984 matching lines @@
     JUnitTestCase.assertNotNull(constructor.returnType);
     JUnitTestCase.assertNull(constructor.period);
     JUnitTestCase.assertNull(constructor.name);
     JUnitTestCase.assertNotNull(constructor.parameters);
     JUnitTestCase.assertNotNull(constructor.separator);
     EngineTestCase.assertSizeOfList(0, constructor.initializers);
     JUnitTestCase.assertNotNull(constructor.redirectedConstructor);
     JUnitTestCase.assertNotNull(constructor.body);
   }
 
-  void test_parseClassTypeAlias() {
-    Token token = TokenFactory.tokenFromKeyword(Keyword.CLASS);
-    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), null, 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.tokenFromKeyword(Keyword.CLASS);
-    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), null, token], "A = abstract B;");
+    Token classToken = TokenFactory.tokenFromKeyword(Keyword.CLASS);
+    Token abstractToken = TokenFactory.tokenFromKeyword(Keyword.ABSTRACT);
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), abstractToken, classToken], "A = B with C;");
     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.assertNotNull(classTypeAlias.withClause);
     JUnitTestCase.assertNull(classTypeAlias.implementsClause);
     JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
   }
 
   void test_parseClassTypeAlias_implements() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.CLASS);
-    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), null, token], "A = B implements C;");
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), null, 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.assertNull(classTypeAlias.withClause);
+    JUnitTestCase.assertNotNull(classTypeAlias.withClause);
     JUnitTestCase.assertNotNull(classTypeAlias.implementsClause);
     JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
   }
 
   void test_parseClassTypeAlias_with() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.CLASS);
     ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), null, token], "A = B with C;");
     JUnitTestCase.assertNotNull(classTypeAlias.keyword);
     JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.equals);
@@ skipping 476 matching lines @@
   }
 
   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);
     JUnitTestCase.assertNotNull(declaration.returnType);
   }
 
   void test_parseCompilationUnitMember_typeAlias_abstract() {
-    ClassTypeAlias typeAlias = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "class C = abstract S with M;");
+    ClassTypeAlias typeAlias = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "abstract class C = 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);
   }
@@ skipping 111 matching lines @@
     MapLiteral literal = ParserTestCase.parse4("parseConstExpression", "const {}", []);
     JUnitTestCase.assertNotNull(literal.leftBracket);
     EngineTestCase.assertSizeOfList(0, literal.entries);
     JUnitTestCase.assertNotNull(literal.rightBracket);
     JUnitTestCase.assertNull(literal.typeArguments);
   }
 
   void test_parseConstructor() {
   }
 
+  void test_parseConstructor_with_pseudo_function_literal() {
+    // "(b) {}" should not be misinterpreted as a function literal even though it looks like one.
+    ClassMember classMember = ParserTestCase.parse("parseClassMember", <Object> ["C"], "C() : a = (b) {}");
+    EngineTestCase.assertInstanceOf((obj) => obj is ConstructorDeclaration, ConstructorDeclaration, classMember);
+    ConstructorDeclaration constructor = classMember as ConstructorDeclaration;
+    NodeList<ConstructorInitializer> initializers = constructor.initializers;
+    EngineTestCase.assertSizeOfList(1, initializers);
+    ConstructorInitializer initializer = initializers[0];
+    EngineTestCase.assertInstanceOf((obj) => obj is ConstructorFieldInitializer, ConstructorFieldInitializer, initializer);
+    EngineTestCase.assertInstanceOf((obj) => obj is ParenthesizedExpression, ParenthesizedExpression, (initializer as ConstructorFieldInitializer).expression);
+    EngineTestCase.assertInstanceOf((obj) => obj is BlockFunctionBody, BlockFunctionBody, constructor.body);
+  }
+
   void test_parseConstructorFieldInitializer_qualified() {
     ConstructorFieldInitializer invocation = ParserTestCase.parse4("parseConstructorFieldInitializer", "this.a = b", []);
     JUnitTestCase.assertNotNull(invocation.equals);
     JUnitTestCase.assertNotNull(invocation.expression);
     JUnitTestCase.assertNotNull(invocation.fieldName);
     JUnitTestCase.assertNotNull(invocation.keyword);
     JUnitTestCase.assertNotNull(invocation.period);
   }
 
   void test_parseConstructorFieldInitializer_unqualified() {
@@ skipping 2879 matching lines @@
         runJUnitTest(__test, __test.test_constFactory);
       });
       _ut.test('test_createSyntheticIdentifier', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_createSyntheticIdentifier);
       });
       _ut.test('test_createSyntheticStringLiteral', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_createSyntheticStringLiteral);
       });
+      _ut.test('test_function_literal_allowed_at_toplevel', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_function_literal_allowed_at_toplevel);
+      });
+      _ut.test('test_function_literal_allowed_in_ArgumentList_in_ConstructorFieldInitializer', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_function_literal_allowed_in_ArgumentList_in_ConstructorFieldInitializer);
+      });
+      _ut.test('test_function_literal_allowed_in_IndexExpression_in_ConstructorFieldInitializer', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_function_literal_allowed_in_IndexExpression_in_ConstructorFieldInitializer);
+      });
+      _ut.test('test_function_literal_allowed_in_ListLiteral_in_ConstructorFieldInitializer', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_function_literal_allowed_in_ListLiteral_in_ConstructorFieldInitializer);
+      });
+      _ut.test('test_function_literal_allowed_in_MapLiteral_in_ConstructorFieldInitializer', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_function_literal_allowed_in_MapLiteral_in_ConstructorFieldInitializer);
+      });
+      _ut.test('test_function_literal_allowed_in_ParenthesizedExpression_in_ConstructorFieldInitializer', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_function_literal_allowed_in_ParenthesizedExpression_in_ConstructorFieldInitializer);
+      });
+      _ut.test('test_function_literal_allowed_in_StringInterpolation_in_ConstructorFieldInitializer', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_function_literal_allowed_in_StringInterpolation_in_ConstructorFieldInitializer);
+      });
       _ut.test('test_isFunctionDeclaration_nameButNoReturn_block', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_isFunctionDeclaration_nameButNoReturn_block);
       });
       _ut.test('test_isFunctionDeclaration_nameButNoReturn_expression', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_isFunctionDeclaration_nameButNoReturn_expression);
       });
       _ut.test('test_isFunctionDeclaration_normalReturn_block', () {
         final __test = new SimpleParserTest();
@@ skipping 472 matching lines @@
         runJUnitTest(__test, __test.test_parseClassMember_operator_indexAssign);
       });
       _ut.test('test_parseClassMember_redirectingFactory_const', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseClassMember_redirectingFactory_const);
       });
       _ut.test('test_parseClassMember_redirectingFactory_nonConst', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseClassMember_redirectingFactory_nonConst);
       });
-      _ut.test('test_parseClassTypeAlias', () {
-        final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseClassTypeAlias);
-      });
       _ut.test('test_parseClassTypeAlias_abstract', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseClassTypeAlias_abstract);
       });
       _ut.test('test_parseClassTypeAlias_implements', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseClassTypeAlias_implements);
       });
       _ut.test('test_parseClassTypeAlias_with', () {
         final __test = new SimpleParserTest();
@@ skipping 312 matching lines @@
         runJUnitTest(__test, __test.test_parseConstructorName_named_prefixed);
       });
       _ut.test('test_parseConstructorName_unnamed_noPrefix', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseConstructorName_unnamed_noPrefix);
       });
       _ut.test('test_parseConstructorName_unnamed_prefixed', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseConstructorName_unnamed_prefixed);
       });
+      _ut.test('test_parseConstructor_with_pseudo_function_literal', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseConstructor_with_pseudo_function_literal);
+      });
       _ut.test('test_parseContinueStatement_label', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseContinueStatement_label);
       });
       _ut.test('test_parseContinueStatement_noLabel', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseContinueStatement_noLabel);
       });
       _ut.test('test_parseDirective_export', () {
         final __test = new SimpleParserTest();
@@ skipping 3168 matching lines @@
   }
 
   void test_expressionList_multiple_start() {
     List<Expression> result = ParserTestCase.parse4("parseExpressionList", "1, 2, 3,", [ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertSizeOfList(4, result);
     Expression syntheticExpression = result[3];
     EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, syntheticExpression);
     JUnitTestCase.assertTrue(syntheticExpression.isSynthetic);
   }
 
+  void test_functionExpression_in_ConstructorFieldInitializer() {
+    CompilationUnit unit = ParserTestCase.parseCompilationUnit("class A { A() : a = (){}; var v; }", [
+        ParserErrorCode.MISSING_IDENTIFIER,
+        ParserErrorCode.UNEXPECTED_TOKEN]);
+    // Make sure we recovered and parsed "var v" correctly
+    ClassDeclaration declaration = unit.declarations[0] as ClassDeclaration;
+    NodeList<ClassMember> members = declaration.members;
+    ClassMember fieldDecl = members[1];
+    EngineTestCase.assertInstanceOf((obj) => obj is FieldDeclaration, FieldDeclaration, fieldDecl);
+    NodeList<VariableDeclaration> vars = (fieldDecl as FieldDeclaration).fields.variables;
+    EngineTestCase.assertSizeOfList(1, vars);
+    JUnitTestCase.assertEquals("v", vars[0].name.name);
+  }
+
   void test_incomplete_topLevelVariable() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("String", [ParserErrorCode.EXPECTED_EXECUTABLE]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     EngineTestCase.assertSizeOfList(1, declarations);
     CompilationUnitMember member = declarations[0];
     EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableDeclaration, TopLevelVariableDeclaration, member);
     NodeList<VariableDeclaration> variables = (member as TopLevelVariableDeclaration).variables.variables;
     EngineTestCase.assertSizeOfList(1, variables);
     SimpleIdentifier name = variables[0].name;
     JUnitTestCase.assertTrue(name.isSynthetic);
@@ skipping 425 matching lines @@
         runJUnitTest(__test, __test.test_expressionList_multiple_end);
       });
       _ut.test('test_expressionList_multiple_middle', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_expressionList_multiple_middle);
       });
       _ut.test('test_expressionList_multiple_start', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_expressionList_multiple_start);
       });
+      _ut.test('test_functionExpression_in_ConstructorFieldInitializer', () {
+        final __test = new RecoveryParserTest();
+        runJUnitTest(__test, __test.test_functionExpression_in_ConstructorFieldInitializer);
+      });
       _ut.test('test_incomplete_topLevelVariable', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_incomplete_topLevelVariable);
       });
       _ut.test('test_isExpression_noType', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_isExpression_noType);
       });
       _ut.test('test_logicalAndExpression_missing_LHS', () {
         final __test = new RecoveryParserTest();
@@ skipping 117 matching lines @@
       });
       _ut.test('test_typedef_eof', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_typedef_eof);
       });
     });
   }
 }
 
 class IncrementalParserTest extends EngineTestCase {
+  void fail_replace_identifier_with_functionLiteral_in_initializer() {
+    // Function literals aren't allowed inside initializers; incremental parsing needs to gather
+    // the appropriate context.
+    //
+    // "class A { var a; A(b) : a = b ? b : 0 { } }"
+    // "class A { var a; A(b) : a = b ? () {} : 0 { } }"
+    _assertParse("class A { var a; A(b) : a = b ? ", "b", "() {}", " : 0 { } }");
+  }
+
   void test_delete_everything() {
     // "f() => a + b;"
     // ""
     _assertParse("", "f() => a + b;", "", "");
   }
 
   void test_delete_identifier_beginning() {
     // "f() => abs + b;"
     // "f() => s + b;"
     _assertParse("f() => ", "ab", "", "s + b;");
@@ skipping 229 matching lines @@
     IncrementalScanner incrementalScanner = new IncrementalScanner(source, new CharSequenceReader(modifiedContents), incrementalListener);
     Token incrementalTokens = incrementalScanner.rescan(originalTokens, replaceStart, removed.length, added.length);
     JUnitTestCase.assertNotNull(incrementalTokens);
     IncrementalParser incrementalParser = new IncrementalParser(source, incrementalScanner.tokenMap, incrementalListener);
     CompilationUnit incrementalUnit = incrementalParser.reparse(originalUnit, incrementalScanner.leftToken, incrementalScanner.rightToken, replaceStart, prefix.length + removed.length);
     JUnitTestCase.assertNotNull(incrementalUnit);
     //
     // Validate that the results of the incremental parse are the same as the full parse of the
     // modified source.
     //
-    JUnitTestCase.assertTrue(AstComparator.equalUnits(modifiedUnit, incrementalUnit));
+    JUnitTestCase.assertTrue(AstComparator.equalNodes(modifiedUnit, incrementalUnit));
   }
 
   static dartSuite() {
     _ut.group('IncrementalParserTest', () {
       _ut.test('test_delete_everything', () {
         final __test = new IncrementalParserTest();
         runJUnitTest(__test, __test.test_delete_everything);
       });
       _ut.test('test_delete_identifier_beginning', () {
         final __test = new IncrementalParserTest();
@@ skipping 282 matching lines @@
   }
 
   void test_breakOutsideOfLoop_functionExpression_inALoop() {
     ParserTestCase.parseStatement("for(; x;) {() {break;};}", [ParserErrorCode.BREAK_OUTSIDE_OF_LOOP]);
   }
 
   void test_breakOutsideOfLoop_functionExpression_withALoop() {
     ParserTestCase.parseStatement("() {for (; x;) {break;}};", []);
   }
 
+  void test_classTypeAlias_abstractAfterEq() {
+    // This syntax has been removed from the language in favor of "abstract class A = B with C;"
+    // (issue 18098).
+    ParserTestCase.parse3("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "class A = abstract B with C;", [
+        ParserErrorCode.EXPECTED_TOKEN,
+        ParserErrorCode.EXPECTED_TOKEN]);
+  }
+
   void test_constAndFinal() {
     ParserTestCase.parse3("parseClassMember", <Object> ["C"], "const final int x;", [ParserErrorCode.CONST_AND_FINAL]);
   }
 
   void test_constAndVar() {
     ParserTestCase.parse3("parseClassMember", <Object> ["C"], "const var x;", [ParserErrorCode.CONST_AND_VAR]);
   }
 
   void test_constClass() {
     ParserTestCase.parseCompilationUnit("const class C {}", [ParserErrorCode.CONST_CLASS]);
@@ skipping 57 matching lines @@
 
   void test_continueWithoutLabelInCase_noError() {
     ParserTestCase.parse4("parseSwitchStatement", "switch (x) {case 1: continue a;}", []);
   }
 
   void test_continueWithoutLabelInCase_noError_switchInLoop() {
     ParserTestCase.parse4("parseWhileStatement", "while (a) { switch (b) {default: continue;}}", []);
   }
 
   void test_deprecatedClassTypeAlias() {
-    ParserTestCase.parseCompilationUnit("typedef C = abstract S with M;", [ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS]);
+    ParserTestCase.parseCompilationUnit("typedef C = S with M;", [ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS]);
   }
 
   void test_deprecatedClassTypeAlias_withGeneric() {
-    ParserTestCase.parseCompilationUnit("typedef C<T> = abstract S<T> with M;", [ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS]);
+    ParserTestCase.parseCompilationUnit("typedef C<T> = S<T> with M;", [ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS]);
   }
 
   void test_directiveAfterDeclaration_classBeforeDirective() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("class Foo{} library l;", [ParserErrorCode.DIRECTIVE_AFTER_DECLARATION]);
     JUnitTestCase.assertNotNull(unit);
   }
 
   void test_directiveAfterDeclaration_classBetweenDirectives() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("library l;\nclass Foo{}\npart 'a.dart';", [ParserErrorCode.DIRECTIVE_AFTER_DECLARATION]);
     JUnitTestCase.assertNotNull(unit);
@@ skipping 88 matching lines @@
   }
 
   void test_expectedToken_parseStatement_afterVoid() {
     ParserTestCase.parseStatement("void}", [
         ParserErrorCode.EXPECTED_TOKEN,
         ParserErrorCode.MISSING_IDENTIFIER]);
   }
 
   void test_expectedToken_semicolonAfterClass() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.CLASS);
-    ParserTestCase.parse3("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), null, token], "A = B", [ParserErrorCode.EXPECTED_TOKEN]);
+    ParserTestCase.parse3("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), null, token], "A = B with C", [ParserErrorCode.EXPECTED_TOKEN]);
   }
 
   void test_expectedToken_semicolonMissingAfterExport() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("export '' class A {}", [ParserErrorCode.EXPECTED_TOKEN]);
     ExportDirective directive = unit.directives[0] as ExportDirective;
     Token semicolon = directive.semicolon;
     JUnitTestCase.assertNotNull(semicolon);
     JUnitTestCase.assertTrue(semicolon.isSynthetic);
   }
 
@@ skipping 433 matching lines @@
   }
 
   void test_mixedParameterGroups_namedPositional() {
     ParserTestCase.parse4("parseFormalParameterList", "(a, {b}, [c])", [ParserErrorCode.MIXED_PARAMETER_GROUPS]);
   }
 
   void test_mixedParameterGroups_positionalNamed() {
     ParserTestCase.parse4("parseFormalParameterList", "(a, [b], {c})", [ParserErrorCode.MIXED_PARAMETER_GROUPS]);
   }
 
+  void test_mixin_application_lacks_with_clause() {
+    ParserTestCase.parseCompilationUnit("class Foo = Bar;", [ParserErrorCode.EXPECTED_TOKEN]);
+  }
+
   void test_multipleExtendsClauses() {
     ParserTestCase.parseCompilationUnit("class A extends B extends C {}", [ParserErrorCode.MULTIPLE_EXTENDS_CLAUSES]);
   }
 
   void test_multipleImplementsClauses() {
     ParserTestCase.parseCompilationUnit("class A implements B implements C {}", [ParserErrorCode.MULTIPLE_IMPLEMENTS_CLAUSES]);
   }
 
   void test_multipleLibraryDirectives() {
     ParserTestCase.parseCompilationUnit("library l; library m;", [ParserErrorCode.MULTIPLE_LIBRARY_DIRECTIVES]);
@@ skipping 357 matching lines @@
         runJUnitTest(__test, __test.test_breakOutsideOfLoop_breakInWhileStatement);
       });
       _ut.test('test_breakOutsideOfLoop_functionExpression_inALoop', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_breakOutsideOfLoop_functionExpression_inALoop);
       });
       _ut.test('test_breakOutsideOfLoop_functionExpression_withALoop', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_breakOutsideOfLoop_functionExpression_withALoop);
       });
+      _ut.test('test_classTypeAlias_abstractAfterEq', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_classTypeAlias_abstractAfterEq);
+      });
       _ut.test('test_constAndFinal', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_constAndFinal);
       });
       _ut.test('test_constAndVar', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_constAndVar);
       });
       _ut.test('test_constClass', () {
         final __test = new ErrorParserTest();
@@ skipping 592 matching lines @@
         runJUnitTest(__test, __test.test_missingVariableInForEach);
       });
       _ut.test('test_mixedParameterGroups_namedPositional', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_mixedParameterGroups_namedPositional);
       });
       _ut.test('test_mixedParameterGroups_positionalNamed', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_mixedParameterGroups_positionalNamed);
       });
+      _ut.test('test_mixin_application_lacks_with_clause', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_mixin_application_lacks_with_clause);
+      });
       _ut.test('test_multipleExtendsClauses', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_multipleExtendsClauses);
       });
       _ut.test('test_multipleImplementsClauses', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_multipleImplementsClauses);
       });
       _ut.test('test_multipleLibraryDirectives', () {
         final __test = new ErrorParserTest();
@@ skipping 269 matching lines @@
 
 main() {
   ComplexParserTest.dartSuite();
   ErrorParserTest.dartSuite();
   IncrementalParserTest.dartSuite();
   NonErrorParserTest.dartSuite();
   RecoveryParserTest.dartSuite();
   ResolutionCopierTest.dartSuite();
   SimpleParserTest.dartSuite();
 }