Push new analyzer-experimental with Resolver and ResolverTest.

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 'dart:collection';
 import 'package:analyzer-experimental/src/generated/java_core.dart';
 import 'package:analyzer-experimental/src/generated/java_engine.dart';
 import 'package:analyzer-experimental/src/generated/java_junit.dart';
 import 'package:analyzer-experimental/src/generated/source.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';
 import 'package:unittest/unittest.dart' as _ut;
 import 'test_support.dart';
 import 'scanner_test.dart' show TokenFactory;
 
 /**
  * The class {@code SimpleParserTest} defines parser tests that test individual parsing method. The
  * code fragments should be as minimal as possible in order to test the method, but should not test
  * the interactions between the method under test and other methods.
  * <p>
  * More complex tests should be defined in the class {@link ComplexParserTest}.
  */
 class SimpleParserTest extends ParserTestCase {
   void fail_parseCommentReference_this() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["this", 5], "");
-    SimpleIdentifier identifier18 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
-    JUnitTestCase.assertNotNull(identifier18.token);
-    JUnitTestCase.assertEquals("a", identifier18.name);
-    JUnitTestCase.assertEquals(5, identifier18.offset);
+    SimpleIdentifier identifier19 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
+    JUnitTestCase.assertNotNull(identifier19.token);
+    JUnitTestCase.assertEquals("a", identifier19.name);
+    JUnitTestCase.assertEquals(5, identifier19.offset);
   }
   void test_computeStringValue_emptyInterpolationPrefix() {
     JUnitTestCase.assertEquals("", computeStringValue("'''"));
   }
   void test_computeStringValue_escape_b() {
     JUnitTestCase.assertEquals("\b", computeStringValue("'\\b'"));
   }
   void test_computeStringValue_escape_f() {
     JUnitTestCase.assertEquals("\f", computeStringValue("'\\f'"));
   }
@@ skipping 212 matching lines @@
   void test_parseAnnotation_n3_a() {
     Annotation annotation = ParserTestCase.parse6("parseAnnotation", "@A.B.C(x,y)", []);
     JUnitTestCase.assertNotNull(annotation.atSign);
     JUnitTestCase.assertNotNull(annotation.name);
     JUnitTestCase.assertNotNull(annotation.period);
     JUnitTestCase.assertNotNull(annotation.constructorName);
     JUnitTestCase.assertNotNull(annotation.arguments);
   }
   void test_parseArgument_named() {
     NamedExpression expression = ParserTestCase.parse6("parseArgument", "n: x", []);
-    Label name21 = expression.name;
-    JUnitTestCase.assertNotNull(name21);
-    JUnitTestCase.assertNotNull(name21.label);
-    JUnitTestCase.assertNotNull(name21.colon);
+    Label name22 = expression.name;
+    JUnitTestCase.assertNotNull(name22);
+    JUnitTestCase.assertNotNull(name22.label);
+    JUnitTestCase.assertNotNull(name22.colon);
     JUnitTestCase.assertNotNull(expression.expression);
   }
   void test_parseArgument_unnamed() {
     String lexeme = "x";
     SimpleIdentifier identifier = ParserTestCase.parse6("parseArgument", lexeme, []);
     JUnitTestCase.assertEquals(lexeme, identifier.name);
   }
   void test_parseArgumentDefinitionTest() {
     ArgumentDefinitionTest test = ParserTestCase.parse6("parseArgumentDefinitionTest", "?x", []);
     JUnitTestCase.assertNotNull(test.question);
@@ skipping 701 matching lines @@
     EngineTestCase.assertSize(0, commentAndMetadata.metadata);
   }
   void test_parseCommentReference_new_prefixed() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["new a.b", 7], "");
     PrefixedIdentifier prefixedIdentifier = EngineTestCase.assertInstanceOf(PrefixedIdentifier, reference.identifier);
     SimpleIdentifier prefix11 = prefixedIdentifier.prefix;
     JUnitTestCase.assertNotNull(prefix11.token);
     JUnitTestCase.assertEquals("a", prefix11.name);
     JUnitTestCase.assertEquals(11, prefix11.offset);
     JUnitTestCase.assertNotNull(prefixedIdentifier.period);
-    SimpleIdentifier identifier19 = prefixedIdentifier.identifier;
-    JUnitTestCase.assertNotNull(identifier19.token);
-    JUnitTestCase.assertEquals("b", identifier19.name);
-    JUnitTestCase.assertEquals(13, identifier19.offset);
+    SimpleIdentifier identifier20 = prefixedIdentifier.identifier;
+    JUnitTestCase.assertNotNull(identifier20.token);
+    JUnitTestCase.assertEquals("b", identifier20.name);
+    JUnitTestCase.assertEquals(13, identifier20.offset);
   }
   void test_parseCommentReference_new_simple() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["new a", 5], "");
-    SimpleIdentifier identifier20 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
-    JUnitTestCase.assertNotNull(identifier20.token);
-    JUnitTestCase.assertEquals("a", identifier20.name);
-    JUnitTestCase.assertEquals(9, identifier20.offset);
+    SimpleIdentifier identifier21 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
+    JUnitTestCase.assertNotNull(identifier21.token);
+    JUnitTestCase.assertEquals("a", identifier21.name);
+    JUnitTestCase.assertEquals(9, identifier21.offset);
   }
   void test_parseCommentReference_prefixed() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["a.b", 7], "");
     PrefixedIdentifier prefixedIdentifier = EngineTestCase.assertInstanceOf(PrefixedIdentifier, reference.identifier);
     SimpleIdentifier prefix12 = prefixedIdentifier.prefix;
     JUnitTestCase.assertNotNull(prefix12.token);
     JUnitTestCase.assertEquals("a", prefix12.name);
     JUnitTestCase.assertEquals(7, prefix12.offset);
     JUnitTestCase.assertNotNull(prefixedIdentifier.period);
-    SimpleIdentifier identifier21 = prefixedIdentifier.identifier;
-    JUnitTestCase.assertNotNull(identifier21.token);
-    JUnitTestCase.assertEquals("b", identifier21.name);
-    JUnitTestCase.assertEquals(9, identifier21.offset);
+    SimpleIdentifier identifier22 = prefixedIdentifier.identifier;
+    JUnitTestCase.assertNotNull(identifier22.token);
+    JUnitTestCase.assertEquals("b", identifier22.name);
+    JUnitTestCase.assertEquals(9, identifier22.offset);
   }
   void test_parseCommentReference_simple() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["a", 5], "");
-    SimpleIdentifier identifier22 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
-    JUnitTestCase.assertNotNull(identifier22.token);
-    JUnitTestCase.assertEquals("a", identifier22.name);
-    JUnitTestCase.assertEquals(5, identifier22.offset);
+    SimpleIdentifier identifier23 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
+    JUnitTestCase.assertNotNull(identifier23.token);
+    JUnitTestCase.assertEquals("a", identifier23.name);
+    JUnitTestCase.assertEquals(5, identifier23.offset);
   }
   void test_parseCommentReferences_multiLine() {
     List<Token> tokens = <Token> [new StringToken(TokenType.MULTI_LINE_COMMENT, "/** xxx [a] yyy [b] zzz */", 3)];
     List<CommentReference> references = ParserTestCase.parse("parseCommentReferences", <Object> [tokens], "");
     EngineTestCase.assertSize(2, references);
     CommentReference reference = references[0];
     JUnitTestCase.assertNotNull(reference);
     JUnitTestCase.assertNotNull(reference.identifier);
     JUnitTestCase.assertEquals(12, reference.offset);
     reference = references[1];
@@ skipping 92 matching lines @@
     TopLevelVariableDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "const int x = 0;");
     JUnitTestCase.assertNotNull(declaration.semicolon);
     JUnitTestCase.assertNotNull(declaration.variables);
   }
   void test_parseCompilationUnitMember_finalVariable() {
     TopLevelVariableDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "final x = 0;");
     JUnitTestCase.assertNotNull(declaration.semicolon);
     JUnitTestCase.assertNotNull(declaration.variables);
   }
   void test_parseCompilationUnitMember_function_external_noType() {
-    FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "external f()");
+    FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "external f();");
     JUnitTestCase.assertNotNull(declaration.externalKeyword);
     JUnitTestCase.assertNotNull(declaration.functionExpression);
     JUnitTestCase.assertNull(declaration.propertyKeyword);
   }
   void test_parseCompilationUnitMember_function_external_type() {
-    FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "external int f()");
+    FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "external int f();");
     JUnitTestCase.assertNotNull(declaration.externalKeyword);
     JUnitTestCase.assertNotNull(declaration.functionExpression);
     JUnitTestCase.assertNull(declaration.propertyKeyword);
   }
   void test_parseCompilationUnitMember_function_noType() {
     FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "f() {}");
     JUnitTestCase.assertNotNull(declaration.functionExpression);
     JUnitTestCase.assertNull(declaration.propertyKeyword);
   }
   void test_parseCompilationUnitMember_function_type() {
     FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "int f() {}");
     JUnitTestCase.assertNotNull(declaration.functionExpression);
     JUnitTestCase.assertNull(declaration.propertyKeyword);
   }
   void test_parseCompilationUnitMember_getter_external_noType() {
-    FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "external get p");
+    FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "external get p;");
     JUnitTestCase.assertNotNull(declaration.externalKeyword);
     JUnitTestCase.assertNotNull(declaration.functionExpression);
     JUnitTestCase.assertNotNull(declaration.propertyKeyword);
   }
   void test_parseCompilationUnitMember_getter_external_type() {
-    FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "external int get p");
+    FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "external int get p;");
     JUnitTestCase.assertNotNull(declaration.externalKeyword);
     JUnitTestCase.assertNotNull(declaration.functionExpression);
     JUnitTestCase.assertNotNull(declaration.propertyKeyword);
   }
   void test_parseCompilationUnitMember_getter_noType() {
     FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "get p => 0;");
     JUnitTestCase.assertNotNull(declaration.functionExpression);
     JUnitTestCase.assertNotNull(declaration.propertyKeyword);
   }
   void test_parseCompilationUnitMember_getter_type() {
     FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "int get p => 0;");
     JUnitTestCase.assertNotNull(declaration.functionExpression);
     JUnitTestCase.assertNotNull(declaration.propertyKeyword);
   }
   void test_parseCompilationUnitMember_setter_external_noType() {
-    FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "external set p(v)");
+    FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "external set p(v);");
     JUnitTestCase.assertNotNull(declaration.externalKeyword);
     JUnitTestCase.assertNotNull(declaration.functionExpression);
     JUnitTestCase.assertNotNull(declaration.propertyKeyword);
   }
   void test_parseCompilationUnitMember_setter_external_type() {
-    FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "external void set p(int v)");
+    FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "external void set p(int v);");
     JUnitTestCase.assertNotNull(declaration.externalKeyword);
     JUnitTestCase.assertNotNull(declaration.functionExpression);
     JUnitTestCase.assertNotNull(declaration.propertyKeyword);
   }
   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() {
@@ skipping 341 matching lines @@
     JUnitTestCase.assertNotNull(invocation.argumentList);
   }
   void test_parseExtendsClause() {
     ExtendsClause clause = ParserTestCase.parse6("parseExtendsClause", "extends B", []);
     JUnitTestCase.assertNotNull(clause.keyword);
     JUnitTestCase.assertNotNull(clause.superclass);
     EngineTestCase.assertInstanceOf(TypeName, clause.superclass);
   }
   void test_parseFinalConstVarOrType_const_noType() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "const");
-    Token keyword29 = result.keyword;
-    JUnitTestCase.assertNotNull(keyword29);
-    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword29.type);
-    JUnitTestCase.assertEquals(Keyword.CONST, ((keyword29 as KeywordToken)).keyword);
+    Token keyword31 = result.keyword;
+    JUnitTestCase.assertNotNull(keyword31);
+    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword31.type);
+    JUnitTestCase.assertEquals(Keyword.CONST, ((keyword31 as KeywordToken)).keyword);
     JUnitTestCase.assertNull(result.type);
   }
   void test_parseFinalConstVarOrType_const_type() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "const A a");
-    Token keyword30 = result.keyword;
-    JUnitTestCase.assertNotNull(keyword30);
-    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword30.type);
-    JUnitTestCase.assertEquals(Keyword.CONST, ((keyword30 as KeywordToken)).keyword);
+    Token keyword32 = result.keyword;
+    JUnitTestCase.assertNotNull(keyword32);
+    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword32.type);
+    JUnitTestCase.assertEquals(Keyword.CONST, ((keyword32 as KeywordToken)).keyword);
     JUnitTestCase.assertNotNull(result.type);
   }
   void test_parseFinalConstVarOrType_final_noType() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "final");
-    Token keyword31 = result.keyword;
-    JUnitTestCase.assertNotNull(keyword31);
-    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword31.type);
-    JUnitTestCase.assertEquals(Keyword.FINAL, ((keyword31 as KeywordToken)).keyword);
+    Token keyword33 = result.keyword;
+    JUnitTestCase.assertNotNull(keyword33);
+    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword33.type);
+    JUnitTestCase.assertEquals(Keyword.FINAL, ((keyword33 as KeywordToken)).keyword);
     JUnitTestCase.assertNull(result.type);
   }
   void test_parseFinalConstVarOrType_final_type() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "final A a");
-    Token keyword32 = result.keyword;
-    JUnitTestCase.assertNotNull(keyword32);
-    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword32.type);
-    JUnitTestCase.assertEquals(Keyword.FINAL, ((keyword32 as KeywordToken)).keyword);
+    Token keyword34 = result.keyword;
+    JUnitTestCase.assertNotNull(keyword34);
+    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword34.type);
+    JUnitTestCase.assertEquals(Keyword.FINAL, ((keyword34 as KeywordToken)).keyword);
     JUnitTestCase.assertNotNull(result.type);
   }
   void test_parseFinalConstVarOrType_type_parameterized() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "A<B> a");
     JUnitTestCase.assertNull(result.keyword);
     JUnitTestCase.assertNotNull(result.type);
   }
   void test_parseFinalConstVarOrType_type_prefixed() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "p.A a");
     JUnitTestCase.assertNull(result.keyword);
     JUnitTestCase.assertNotNull(result.type);
   }
   void test_parseFinalConstVarOrType_type_prefixedAndParameterized() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "p.A<B> a");
     JUnitTestCase.assertNull(result.keyword);
     JUnitTestCase.assertNotNull(result.type);
   }
   void test_parseFinalConstVarOrType_type_simple() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "A a");
     JUnitTestCase.assertNull(result.keyword);
     JUnitTestCase.assertNotNull(result.type);
   }
   void test_parseFinalConstVarOrType_var() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "var");
-    Token keyword33 = result.keyword;
-    JUnitTestCase.assertNotNull(keyword33);
-    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword33.type);
-    JUnitTestCase.assertEquals(Keyword.VAR, ((keyword33 as KeywordToken)).keyword);
+    Token keyword35 = result.keyword;
+    JUnitTestCase.assertNotNull(keyword35);
+    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword35.type);
+    JUnitTestCase.assertEquals(Keyword.VAR, ((keyword35 as KeywordToken)).keyword);
     JUnitTestCase.assertNull(result.type);
   }
   void test_parseFormalParameter_final_withType_named() {
     ParameterKind kind = ParameterKind.NAMED;
     DefaultFormalParameter parameter = ParserTestCase.parse("parseFormalParameter", <Object> [kind], "final A a : null");
     SimpleFormalParameter simpleParameter = parameter.parameter as SimpleFormalParameter;
     JUnitTestCase.assertNotNull(simpleParameter.identifier);
     JUnitTestCase.assertNotNull(simpleParameter.keyword);
     JUnitTestCase.assertNotNull(simpleParameter.type);
     JUnitTestCase.assertEquals(kind, simpleParameter.kind);
@@ skipping 154 matching lines @@
     JUnitTestCase.assertNotNull(parameterList.leftParenthesis);
     JUnitTestCase.assertNotNull(parameterList.leftDelimiter);
     EngineTestCase.assertSize(1, parameterList.parameters);
     JUnitTestCase.assertNotNull(parameterList.rightDelimiter);
     JUnitTestCase.assertNotNull(parameterList.rightParenthesis);
   }
   void test_parseForStatement_each_identifier() {
     ForEachStatement statement = ParserTestCase.parse6("parseForStatement", "for (element in list) {}", []);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
-    JUnitTestCase.assertNotNull(statement.loopParameter);
+    JUnitTestCase.assertNotNull(statement.loopVariable);
     JUnitTestCase.assertNotNull(statement.inKeyword);
     JUnitTestCase.assertNotNull(statement.iterator);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
   void test_parseForStatement_each_noType() {
     ForEachStatement statement = ParserTestCase.parse6("parseForStatement", "for (element in list) {}", []);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
-    JUnitTestCase.assertNotNull(statement.loopParameter);
+    JUnitTestCase.assertNotNull(statement.loopVariable);
     JUnitTestCase.assertNotNull(statement.inKeyword);
     JUnitTestCase.assertNotNull(statement.iterator);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
   void test_parseForStatement_each_type() {
     ForEachStatement statement = ParserTestCase.parse6("parseForStatement", "for (A element in list) {}", []);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
-    JUnitTestCase.assertNotNull(statement.loopParameter);
+    JUnitTestCase.assertNotNull(statement.loopVariable);
     JUnitTestCase.assertNotNull(statement.inKeyword);
     JUnitTestCase.assertNotNull(statement.iterator);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
   void test_parseForStatement_each_var() {
     ForEachStatement statement = ParserTestCase.parse6("parseForStatement", "for (var element in list) {}", []);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
-    JUnitTestCase.assertNotNull(statement.loopParameter);
+    JUnitTestCase.assertNotNull(statement.loopVariable);
     JUnitTestCase.assertNotNull(statement.inKeyword);
     JUnitTestCase.assertNotNull(statement.iterator);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
   void test_parseForStatement_loop_c() {
     ForStatement statement = ParserTestCase.parse6("parseForStatement", "for (; i < count;) {}", []);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
     JUnitTestCase.assertNull(statement.variables);
@@ skipping 129 matching lines @@
   }
   void test_parseFunctionBody_expression() {
     ExpressionFunctionBody functionBody = ParserTestCase.parse("parseFunctionBody", <Object> [false, false], "=> y;");
     JUnitTestCase.assertNotNull(functionBody.functionDefinition);
     JUnitTestCase.assertNotNull(functionBody.expression);
     JUnitTestCase.assertNotNull(functionBody.semicolon);
   }
   void test_parseFunctionDeclaration_function() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     TypeName returnType = new TypeName.full(new SimpleIdentifier.full(null), null);
-    FunctionDeclaration declaration = ParserTestCase.parse("parseFunctionDeclaration", <Object> [commentAndMetadata(comment, []), null, returnType, false], "f() {}");
+    FunctionDeclaration declaration = ParserTestCase.parse("parseFunctionDeclaration", <Object> [commentAndMetadata(comment, []), null, returnType], "f() {}");
     JUnitTestCase.assertEquals(comment, declaration.documentationComment);
     JUnitTestCase.assertEquals(returnType, declaration.returnType);
     JUnitTestCase.assertNotNull(declaration.name);
-    FunctionExpression expression = declaration.functionExpression;
-    JUnitTestCase.assertNotNull(expression);
-    JUnitTestCase.assertNotNull(expression.body);
-    JUnitTestCase.assertNotNull(expression.parameters);
-    JUnitTestCase.assertNull(declaration.propertyKeyword);
-  }
-  void test_parseFunctionDeclaration_function_inStatement() {
-    Comment comment = Comment.createDocumentationComment(new List<Token>(0));
-    TypeName returnType = new TypeName.full(new SimpleIdentifier.full(null), null);
-    FunctionDeclaration declaration = ParserTestCase.parse("parseFunctionDeclaration", <Object> [commentAndMetadata(comment, []), null, returnType, true], "f() {};");
-    JUnitTestCase.assertEquals(comment, declaration.documentationComment);
-    JUnitTestCase.assertEquals(returnType, declaration.returnType);
-    JUnitTestCase.assertNotNull(declaration.name);
     FunctionExpression expression = declaration.functionExpression;
     JUnitTestCase.assertNotNull(expression);
     JUnitTestCase.assertNotNull(expression.body);
     JUnitTestCase.assertNotNull(expression.parameters);
     JUnitTestCase.assertNull(declaration.propertyKeyword);
   }
   void test_parseFunctionDeclaration_getter() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     TypeName returnType = new TypeName.full(new SimpleIdentifier.full(null), null);
-    FunctionDeclaration declaration = ParserTestCase.parse("parseFunctionDeclaration", <Object> [commentAndMetadata(comment, []), null, returnType, false], "get p => 0;");
+    FunctionDeclaration declaration = ParserTestCase.parse("parseFunctionDeclaration", <Object> [commentAndMetadata(comment, []), null, returnType], "get p => 0;");
     JUnitTestCase.assertEquals(comment, declaration.documentationComment);
     JUnitTestCase.assertEquals(returnType, declaration.returnType);
     JUnitTestCase.assertNotNull(declaration.name);
     FunctionExpression expression = declaration.functionExpression;
     JUnitTestCase.assertNotNull(expression);
     JUnitTestCase.assertNotNull(expression.body);
     JUnitTestCase.assertNull(expression.parameters);
     JUnitTestCase.assertNotNull(declaration.propertyKeyword);
   }
   void test_parseFunctionDeclaration_setter() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     TypeName returnType = new TypeName.full(new SimpleIdentifier.full(null), null);
-    FunctionDeclaration declaration = ParserTestCase.parse("parseFunctionDeclaration", <Object> [commentAndMetadata(comment, []), null, returnType, false], "set p(v) {}");
+    FunctionDeclaration declaration = ParserTestCase.parse("parseFunctionDeclaration", <Object> [commentAndMetadata(comment, []), null, returnType], "set p(v) {}");
     JUnitTestCase.assertEquals(comment, declaration.documentationComment);
     JUnitTestCase.assertEquals(returnType, declaration.returnType);
     JUnitTestCase.assertNotNull(declaration.name);
     FunctionExpression expression = declaration.functionExpression;
     JUnitTestCase.assertNotNull(expression);
     JUnitTestCase.assertNotNull(expression.body);
     JUnitTestCase.assertNotNull(expression.parameters);
     JUnitTestCase.assertNotNull(declaration.propertyKeyword);
   }
   void test_parseFunctionDeclarationStatement() {
@@ skipping 151 matching lines @@
     JUnitTestCase.assertNull(directive.prefix);
     EngineTestCase.assertSize(1, directive.combinators);
     JUnitTestCase.assertNotNull(directive.semicolon);
   }
   void test_parseInitializedIdentifierList_type() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     Token staticKeyword = TokenFactory.token(Keyword.STATIC);
     TypeName type = new TypeName.full(new SimpleIdentifier.full(null), null);
     FieldDeclaration declaration = ParserTestCase.parse("parseInitializedIdentifierList", <Object> [commentAndMetadata(comment, []), staticKeyword, null, type], "a = 1, b, c = 3;");
     JUnitTestCase.assertEquals(comment, declaration.documentationComment);
-    VariableDeclarationList fields3 = declaration.fields;
-    JUnitTestCase.assertNotNull(fields3);
-    JUnitTestCase.assertNull(fields3.keyword);
-    JUnitTestCase.assertEquals(type, fields3.type);
-    EngineTestCase.assertSize(3, fields3.variables);
+    VariableDeclarationList fields4 = declaration.fields;
+    JUnitTestCase.assertNotNull(fields4);
+    JUnitTestCase.assertNull(fields4.keyword);
+    JUnitTestCase.assertEquals(type, fields4.type);
+    EngineTestCase.assertSize(3, fields4.variables);
     JUnitTestCase.assertEquals(staticKeyword, declaration.keyword);
     JUnitTestCase.assertNotNull(declaration.semicolon);
   }
   void test_parseInitializedIdentifierList_var() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     Token staticKeyword = TokenFactory.token(Keyword.STATIC);
     Token varKeyword = TokenFactory.token(Keyword.VAR);
     FieldDeclaration declaration = ParserTestCase.parse("parseInitializedIdentifierList", <Object> [commentAndMetadata(comment, []), staticKeyword, varKeyword, null], "a = 1, b, c = 3;");
     JUnitTestCase.assertEquals(comment, declaration.documentationComment);
-    VariableDeclarationList fields4 = declaration.fields;
-    JUnitTestCase.assertNotNull(fields4);
-    JUnitTestCase.assertEquals(varKeyword, fields4.keyword);
-    JUnitTestCase.assertNull(fields4.type);
-    EngineTestCase.assertSize(3, fields4.variables);
+    VariableDeclarationList fields5 = declaration.fields;
+    JUnitTestCase.assertNotNull(fields5);
+    JUnitTestCase.assertEquals(varKeyword, fields5.keyword);
+    JUnitTestCase.assertNull(fields5.type);
+    EngineTestCase.assertSize(3, fields5.variables);
     JUnitTestCase.assertEquals(staticKeyword, declaration.keyword);
     JUnitTestCase.assertNotNull(declaration.semicolon);
   }
   void test_parseInstanceCreationExpression_qualifiedType() {
     Token token5 = TokenFactory.token(Keyword.NEW);
     InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token5], "A.B()");
     JUnitTestCase.assertEquals(token5, expression.keyword);
     ConstructorName name = expression.constructorName;
     JUnitTestCase.assertNotNull(name);
     JUnitTestCase.assertNotNull(name.type);
@@ skipping 1308 matching lines @@
     JUnitTestCase.assertNotNull(following);
     JUnitTestCase.assertEquals(TokenType.PLUS, following.type);
   }
   /**
    * Invoke the method {@link Parser#computeStringValue(String)} with the given argument.
    * @param lexeme the argument to the method
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    */
   String computeStringValue(String lexeme) {
-    AnalysisErrorListener listener = new AnalysisErrorListener_12();
+    AnalysisErrorListener listener = new AnalysisErrorListener_13();
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(parser, "computeStringValue", <Object> [lexeme], null) as String;
   }
   /**
    * Invoke the method {@link Parser#createSyntheticIdentifier()} with the parser set to the token
    * stream produced by scanning the given source.
    * @param source the source to be scanned to produce the token stream being tested
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    */
@@ skipping 1162 matching lines @@
         runJUnitTest(__test, __test.test_parseFunctionBody_expression);
       });
       _ut.test('test_parseFunctionDeclarationStatement', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseFunctionDeclarationStatement);
       });
       _ut.test('test_parseFunctionDeclaration_function', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseFunctionDeclaration_function);
       });
-      _ut.test('test_parseFunctionDeclaration_function_inStatement', () {
-        final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseFunctionDeclaration_function_inStatement);
-      });
       _ut.test('test_parseFunctionDeclaration_getter', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseFunctionDeclaration_getter);
       });
       _ut.test('test_parseFunctionDeclaration_setter', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseFunctionDeclaration_setter);
       });
       _ut.test('test_parseFunctionExpression_body_inExpression', () {
         final __test = new SimpleParserTest();
@@ skipping 887 matching lines @@
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_skipTypeName_parameterized);
       });
       _ut.test('test_skipTypeName_simple', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_skipTypeName_simple);
       });
     });
   }
 }
-class AnalysisErrorListener_12 implements AnalysisErrorListener {
+class AnalysisErrorListener_13 implements AnalysisErrorListener {
   void onError(AnalysisError event) {
     JUnitTestCase.fail("Unexpected compilation error: ${event.message} (${event.offset}, ${event.length})");
   }
 }
 /**
  * The class {@code ComplexParserTest} defines parser tests that test the parsing of more complex
  * code fragments or the interactions between multiple parsing methods. For example, tests to ensure
  * that the precedence of operations is being handled correctly should be defined in this class.
  * <p>
  * Simpler tests should be defined in the class {@link SimpleParserTest}.
@@ skipping 1055 matching lines @@
     EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
   }
   void test_shiftExpression_precedence_unary_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("<< +", [ParserErrorCode.USE_OF_UNARY_PLUS_OPERATOR]);
     EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
   }
   void test_shiftExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super << <<", []);
     EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
   }
-  void test_topLevelExternalFunction_extraSemicolon() {
-    CompilationUnit unit = ParserTestCase.parseCompilationUnit("external void f(A a);", [ParserErrorCode.UNEXPECTED_TOKEN]);
+  void test_typedef_eof() {
+    CompilationUnit unit = ParserTestCase.parseCompilationUnit("typedef n", [ParserErrorCode.EXPECTED_TOKEN, ParserErrorCode.MISSING_TYPEDEF_PARAMETERS]);
     NodeList<CompilationUnitMember> declarations3 = unit.declarations;
     EngineTestCase.assertSize(1, declarations3);
-    FunctionDeclaration declaration = declarations3[0] as FunctionDeclaration;
-    JUnitTestCase.assertNotNull(declaration);
-  }
-  void test_typedef_eof() {
-    CompilationUnit unit = ParserTestCase.parseCompilationUnit("typedef n", [ParserErrorCode.EXPECTED_TOKEN, ParserErrorCode.MISSING_TYPEDEF_PARAMETERS]);
-    NodeList<CompilationUnitMember> declarations4 = unit.declarations;
-    EngineTestCase.assertSize(1, declarations4);
-    CompilationUnitMember member = declarations4[0];
+    CompilationUnitMember member = declarations3[0];
     EngineTestCase.assertInstanceOf(FunctionTypeAlias, member);
   }
   static dartSuite() {
     _ut.group('RecoveryParserTest', () {
       _ut.test('test_additiveExpression_missing_LHS', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_additiveExpression_missing_LHS);
       });
       _ut.test('test_additiveExpression_missing_LHS_RHS', () {
         final __test = new RecoveryParserTest();
@@ skipping 284 matching lines @@
         runJUnitTest(__test, __test.test_shiftExpression_precedence_unary_left);
       });
       _ut.test('test_shiftExpression_precedence_unary_right', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_shiftExpression_precedence_unary_right);
       });
       _ut.test('test_shiftExpression_super', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_shiftExpression_super);
       });
-      _ut.test('test_topLevelExternalFunction_extraSemicolon', () {
-        final __test = new RecoveryParserTest();
-        runJUnitTest(__test, __test.test_topLevelExternalFunction_extraSemicolon);
-      });
       _ut.test('test_typedef_eof', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_typedef_eof);
       });
     });
   }
 }
 /**
  * The class {@code ErrorParserTest} defines parser tests that test the parsing of code to ensure
  * that errors are correctly reported, and in some cases, not reported.
@@ skipping 1232 matching lines @@
   'parseExportDirective_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseExportDirective(arg0)),
   'parseExpression_0': new MethodTrampoline(0, (Parser target) => target.parseExpression2()),
   'parseExpressionList_0': new MethodTrampoline(0, (Parser target) => target.parseExpressionList()),
   'parseExpressionWithoutCascade_0': new MethodTrampoline(0, (Parser target) => target.parseExpressionWithoutCascade()),
   'parseExtendsClause_0': new MethodTrampoline(0, (Parser target) => target.parseExtendsClause()),
   'parseFinalConstVarOrType_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseFinalConstVarOrType(arg0)),
   'parseFormalParameter_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseFormalParameter(arg0)),
   'parseFormalParameterList_0': new MethodTrampoline(0, (Parser target) => target.parseFormalParameterList()),
   'parseForStatement_0': new MethodTrampoline(0, (Parser target) => target.parseForStatement()),
   'parseFunctionBody_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.parseFunctionBody(arg0, arg1)),
-  'parseFunctionDeclaration_4': new MethodTrampoline(4, (Parser target, arg0, arg1, arg2, arg3) => target.parseFunctionDeclaration(arg0, arg1, arg2, arg3)),
+  'parseFunctionDeclaration_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.parseFunctionDeclaration(arg0, arg1, arg2)),
   'parseFunctionDeclarationStatement_0': new MethodTrampoline(0, (Parser target) => target.parseFunctionDeclarationStatement()),
   'parseFunctionDeclarationStatement_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.parseFunctionDeclarationStatement2(arg0, arg1)),
   'parseFunctionExpression_0': new MethodTrampoline(0, (Parser target) => target.parseFunctionExpression()),
   'parseFunctionTypeAlias_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.parseFunctionTypeAlias(arg0, arg1)),
   'parseGetter_4': new MethodTrampoline(4, (Parser target, arg0, arg1, arg2, arg3) => target.parseGetter(arg0, arg1, arg2, arg3)),
   'parseIdentifierList_0': new MethodTrampoline(0, (Parser target) => target.parseIdentifierList()),
   'parseIfStatement_0': new MethodTrampoline(0, (Parser target) => target.parseIfStatement()),
   'parseImplementsClause_0': new MethodTrampoline(0, (Parser target) => target.parseImplementsClause()),
   'parseImportDirective_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseImportDirective(arg0)),
   'parseInitializedIdentifierList_4': new MethodTrampoline(4, (Parser target, arg0, arg1, arg2, arg3) => target.parseInitializedIdentifierList(arg0, arg1, arg2, arg3)),
@@ skipping 74 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);
 }