Improve error recovery when using 'var' as a type

editor/tools/plugins/com.google.dart.engine_test/src/com/google/dart/engine/parser/ErrorParserTest.java

 /*
  * Copyright (c) 2012, the Dart project authors.
  * 
  * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
  * in compliance with the License. You may obtain a copy of the License at
  * 
  * http://www.eclipse.org/legal/epl-v10.html
  * 
  * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
@@ skipping 25 matching lines @@
         "parseListOrMapLiteral",
         new Object[] {null},
         "1",
         ParserErrorCode.EXPECTED_LIST_OR_MAP_LITERAL);
     assertTrue(literal.isSynthetic());
   }
 
   public void fail_illegalAssignmentToNonAssignable_superAssigned() throws Exception {
     // TODO(brianwilkerson) When this test starts to pass, remove the test
     // test_illegalAssignmentToNonAssignable_superAssigned.
-    parse("parseExpression", "super = x;", ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE);
+    parseExpression("super = x;", ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE);
   }
 
   public void fail_invalidCommentReference__new_nonIdentifier() throws Exception {
     // This test fails because the method parseCommentReference returns null.
     parse(
         "parseCommentReference",
         new Object[] {"new 42", 0},
         "",
         ParserErrorCode.INVALID_COMMENT_REFERENCE);
   }
@@ skipping 39 matching lines @@
   public void fail_missingExpressionInThrow_withoutCascade() throws Exception {
     parse(
         "parseThrowExpressionWithoutCascade",
         "throw;",
         ParserErrorCode.MISSING_EXPRESSION_IN_THROW);
   }
 
   public void fail_missingFunctionParameters_local_nonVoid_block() throws Exception {
     // The parser does not recognize this as a function declaration, so it tries to parse it as an
     // expression statement. It isn't clear what the best error message is in this case.
-    parse("parseStatement", "int f { return x;}", ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
+    parseStatement("int f { return x;}", ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
   }
 
   public void fail_missingFunctionParameters_local_nonVoid_expression() throws Exception {
     // The parser does not recognize this as a function declaration, so it tries to parse it as an
     // expression statement. It isn't clear what the best error message is in this case.
-    parse("parseStatement", "int f => x;", ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
+    parseStatement("int f => x;", ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
   }
 
   public void fail_namedFunctionExpression() throws Exception {
     Expression expression = parse(
         "parsePrimaryExpression",
         "f() {}",
         ParserErrorCode.NAMED_FUNCTION_EXPRESSION);
     assertInstanceOf(FunctionExpression.class, expression);
   }
 
   public void fail_unexpectedToken_invalidPostfixExpression() throws Exception {
     // Note: this might not be the right error to produce, but some error should be produced
-    parse("parseExpression", "f()++", ParserErrorCode.UNEXPECTED_TOKEN);
+    parseExpression("f()++", ParserErrorCode.UNEXPECTED_TOKEN);
   }
 
   public void fail_voidVariable_initializer() throws Exception {
     // The parser parses this as a function declaration statement because that is the only thing
     // that validly starts with 'void'. That causes a different error message to be produced.
-    parse("parseStatement", "void x = 0;", ParserErrorCode.VOID_VARIABLE);
+    parseStatement("void x = 0;", ParserErrorCode.VOID_VARIABLE);
   }
 
   public void fail_voidVariable_noInitializer() throws Exception {
     // The parser parses this as a function declaration statement because that is the only thing
     // that validly starts with 'void'. That causes a different error message to be produced.
-    parse("parseStatement", "void x;", ParserErrorCode.VOID_VARIABLE);
+    parseStatement("void x;", ParserErrorCode.VOID_VARIABLE);
   }
 
   public void test_abstractClassMember_constructor() throws Exception {
     parse(
         "parseClassMember",
         new Object[] {"C"},
         "abstract C.c();",
         ParserErrorCode.ABSTRACT_CLASS_MEMBER);
   }
 
@@ skipping 23 matching lines @@
 
   public void test_abstractClassMember_setter() throws Exception {
     parse(
         "parseClassMember",
         new Object[] {"C"},
         "abstract set m(v);",
         ParserErrorCode.ABSTRACT_CLASS_MEMBER);
   }
 
   public void test_abstractTopLevelFunction_function() throws Exception {
-    parse("parseCompilationUnit", "abstract f(v) {}", ParserErrorCode.ABSTRACT_TOP_LEVEL_FUNCTION);
+    parseCompilationUnit("abstract f(v) {}", ParserErrorCode.ABSTRACT_TOP_LEVEL_FUNCTION);
   }
 
   public void test_abstractTopLevelFunction_getter() throws Exception {
-    parse("parseCompilationUnit", "abstract get m {}", ParserErrorCode.ABSTRACT_TOP_LEVEL_FUNCTION);
+    parseCompilationUnit("abstract get m {}", ParserErrorCode.ABSTRACT_TOP_LEVEL_FUNCTION);
   }
 
   public void test_abstractTopLevelFunction_setter() throws Exception {
-    parse(
-        "parseCompilationUnit",
-        "abstract set m(v) {}",
-        ParserErrorCode.ABSTRACT_TOP_LEVEL_FUNCTION);
+    parseCompilationUnit("abstract set m(v) {}", ParserErrorCode.ABSTRACT_TOP_LEVEL_FUNCTION);
   }
 
   public void test_abstractTopLevelVariable() throws Exception {
-    parse("parseCompilationUnit", "abstract C f;", ParserErrorCode.ABSTRACT_TOP_LEVEL_VARIABLE);
+    parseCompilationUnit("abstract C f;", ParserErrorCode.ABSTRACT_TOP_LEVEL_VARIABLE);
   }
 
   public void test_abstractTypeDef() throws Exception {
-    parse("parseCompilationUnit", "abstract typedef F();", ParserErrorCode.ABSTRACT_TYPEDEF);
+    parseCompilationUnit("abstract typedef F();", ParserErrorCode.ABSTRACT_TYPEDEF);
   }
 
   public void test_breakOutsideOfLoop_breakInDoStatement() throws Exception {
     parse("parseDoStatement", "do {break;} while (x);");
   }
 
   public void test_breakOutsideOfLoop_breakInForStatement() throws Exception {
     parse("parseForStatement", "for (; x;) {break;}");
   }
 
   public void test_breakOutsideOfLoop_breakInIfStatement() throws Exception {
     parse("parseIfStatement", "if (x) {break;}", ParserErrorCode.BREAK_OUTSIDE_OF_LOOP);
   }
 
   public void test_breakOutsideOfLoop_breakInSwitchStatement() throws Exception {
     parse("parseSwitchStatement", "switch (x) {case 1: break;}");
   }
 
   public void test_breakOutsideOfLoop_breakInWhileStatement() throws Exception {
     parse("parseWhileStatement", "while (x) {break;}");
   }
 
   public void test_breakOutsideOfLoop_functionExpression_inALoop() throws Exception {
-    parse("parseStatement", "for(; x;) {() {break;};}", ParserErrorCode.BREAK_OUTSIDE_OF_LOOP);
+    parseStatement("for(; x;) {() {break;};}", ParserErrorCode.BREAK_OUTSIDE_OF_LOOP);
   }
 
   public void test_breakOutsideOfLoop_functionExpression_withALoop() throws Exception {
-    parse("parseStatement", "() {for (; x;) {break;}};");
+    parseStatement("() {for (; x;) {break;}};");
   }
 
   public void test_constAndFinal() throws Exception {
     parse(
         "parseClassMember",
         new Object[] {"C"},
         "const final int x;",
         ParserErrorCode.CONST_AND_FINAL);
   }
 
   public void test_constAndVar() throws Exception {
     parse("parseClassMember", new Object[] {"C"}, "const var x;", ParserErrorCode.CONST_AND_VAR);
   }
 
   public void test_constClass() throws Exception {
-    parse("parseCompilationUnit", "const class C {}", ParserErrorCode.CONST_CLASS);
+    parseCompilationUnit("const class C {}", ParserErrorCode.CONST_CLASS);
   }
 
   public void test_constMethod() throws Exception {
     parse("parseClassMember", new Object[] {"C"}, "const int m() {}", ParserErrorCode.CONST_METHOD);
   }
 
   public void test_constTypedef() throws Exception {
-    parse("parseCompilationUnit", "const typedef F();", ParserErrorCode.CONST_TYPEDEF);
+    parseCompilationUnit("const typedef F();", ParserErrorCode.CONST_TYPEDEF);
   }
 
   public void test_continueOutsideOfLoop_continueInDoStatement() throws Exception {
     parse("parseDoStatement", "do {continue;} while (x);");
   }
 
   public void test_continueOutsideOfLoop_continueInForStatement() throws Exception {
     parse("parseForStatement", "for (; x;) {continue;}");
   }
 
   public void test_continueOutsideOfLoop_continueInIfStatement() throws Exception {
     parse("parseIfStatement", "if (x) {continue;}", ParserErrorCode.CONTINUE_OUTSIDE_OF_LOOP);
   }
 
   public void test_continueOutsideOfLoop_continueInSwitchStatement() throws Exception {
     parse("parseSwitchStatement", "switch (x) {case 1: continue a;}");
   }
 
   public void test_continueOutsideOfLoop_continueInWhileStatement() throws Exception {
     parse("parseWhileStatement", "while (x) {continue;}");
   }
 
   public void test_continueOutsideOfLoop_functionExpression_inALoop() throws Exception {
-    parse("parseStatement", "for(; x;) {() {continue;};}", ParserErrorCode.CONTINUE_OUTSIDE_OF_LOOP);
+    parseStatement("for(; x;) {() {continue;};}", ParserErrorCode.CONTINUE_OUTSIDE_OF_LOOP);
   }
 
   public void test_continueOutsideOfLoop_functionExpression_withALoop() throws Exception {
-    parse("parseStatement", "() {for (; x;) {continue;}};");
+    parseStatement("() {for (; x;) {continue;}};");
   }
 
   public void test_continueWithoutLabelInCase_error() throws Exception {
     parse(
         "parseSwitchStatement",
         "switch (x) {case 1: continue;}",
         ParserErrorCode.CONTINUE_WITHOUT_LABEL_IN_CASE);
   }
 
   public void test_continueWithoutLabelInCase_noError() throws Exception {
     parse("parseSwitchStatement", "switch (x) {case 1: continue a;}");
   }
 
   public void test_continueWithoutLabelInCase_noError_switchInLoop() throws Exception {
     parse("parseWhileStatement", "while (a) { switch (b) {default: continue;}}");
   }
 
   public void test_directiveAfterDeclaration_classBeforeDirective() throws Exception {
-    CompilationUnit unit = parse(
-        "parseCompilationUnit",
+    CompilationUnit unit = parseCompilationUnit(
         "class Foo{} library l;",
         ParserErrorCode.DIRECTIVE_AFTER_DECLARATION);
     assertNotNull(unit);
   }
 
   public void test_directiveAfterDeclaration_classBetweenDirectives() throws Exception {
-    CompilationUnit unit = parse(
-        "parseCompilationUnit",
+    CompilationUnit unit = parseCompilationUnit(
         "library l;\nclass Foo{}\npart 'a.dart';",
         ParserErrorCode.DIRECTIVE_AFTER_DECLARATION);
     assertNotNull(unit);
   }
 
   public void test_duplicatedModifier_const() throws Exception {
     parse(
         "parseClassMember",
         new Object[] {"C"},
         "const const m;",
@@ skipping 97 matching lines @@
         "1",
         ParserErrorCode.EXPECTED_STRING_LITERAL);
     assertTrue(expression.isSynthetic());
   }
 
   public void test_expectedToken_commaMissingInArgumentList() throws Exception {
     parse("parseArgumentList", "(x, y z)", ParserErrorCode.EXPECTED_TOKEN);
   }
 
   public void test_expectedToken_semicolonMissingAfterExpression() throws Exception {
-    parse("parseStatement", "x", ParserErrorCode.EXPECTED_TOKEN);
+    parseStatement("x", ParserErrorCode.EXPECTED_TOKEN);
   }
 
   public void test_expectedToken_whileMissingInDoStatement() throws Exception {
-    parse("parseStatement", "do {} (x);", ParserErrorCode.EXPECTED_TOKEN);
+    parseStatement("do {} (x);", ParserErrorCode.EXPECTED_TOKEN);
+  }
+
+  public void test_expectedTypeName_is() throws Exception {
+    parseExpression("x is", ParserErrorCode.EXPECTED_TYPE_NAME);
   }
 
   public void test_exportDirectiveAfterPartDirective() throws Exception {
-    parse(
-        "parseCompilationUnit",
+    parseCompilationUnit(
         "part 'a.dart'; export 'b.dart';",
         ParserErrorCode.EXPORT_DIRECTIVE_AFTER_PART_DIRECTIVE);
   }
 
   public void test_externalAfterConst() throws Exception {
     parse(
         "parseClassMember",
         new Object[] {"C"},
         "const external C();",
         ParserErrorCode.EXTERNAL_AFTER_CONST);
   }
 
   public void test_externalAfterFactory() throws Exception {
     parse(
         "parseClassMember",
         new Object[] {"C"},
         "factory external C();",
         ParserErrorCode.EXTERNAL_AFTER_FACTORY);
   }
 
   public void test_externalAfterStatic() throws Exception {
     parse(
         "parseClassMember",
         new Object[] {"C"},
         "static external int m();",
         ParserErrorCode.EXTERNAL_AFTER_STATIC);
   }
 
   public void test_externalClass() throws Exception {
-    parse("parseCompilationUnit", "external class C {}", ParserErrorCode.EXTERNAL_CLASS);
+    parseCompilationUnit("external class C {}", ParserErrorCode.EXTERNAL_CLASS);
   }
 
   public void test_externalConstructorWithBody_factory() throws Exception {
     parse(
         "parseClassMember",
         new Object[] {"C"},
         "external factory C() {}",
         ParserErrorCode.EXTERNAL_CONSTRUCTOR_WITH_BODY);
   }
 
@@ skipping 63 matching lines @@
 
   public void test_externalSetterWithBody() throws Exception {
     parse(
         "parseClassMember",
         new Object[] {"C"},
         "external set x(int value) {}",
         ParserErrorCode.EXTERNAL_SETTER_WITH_BODY);
   }
 
   public void test_externalTypedef() throws Exception {
-    parse("parseCompilationUnit", "external typedef F();", ParserErrorCode.EXTERNAL_TYPEDEF);
+    parseCompilationUnit("external typedef F();", ParserErrorCode.EXTERNAL_TYPEDEF);
   }
 
   public void test_factoryTopLevelDeclaration_class() throws Exception {
-    parse(
-        "parseCompilationUnit",
-        "factory class C {}",
-        ParserErrorCode.FACTORY_TOP_LEVEL_DECLARATION);
+    parseCompilationUnit("factory class C {}", ParserErrorCode.FACTORY_TOP_LEVEL_DECLARATION);
   }
 
   public void test_factoryTopLevelDeclaration_typedef() throws Exception {
-    parse(
-        "parseCompilationUnit",
-        "factory typedef F();",
-        ParserErrorCode.FACTORY_TOP_LEVEL_DECLARATION);
+    parseCompilationUnit("factory typedef F();", ParserErrorCode.FACTORY_TOP_LEVEL_DECLARATION);
   }
 
   public void test_fieldInitializerOutsideConstructor() throws Exception {
     parse(
         "parseClassMember",
         new Object[] {"C"},
         "void m(this.x);",
         ParserErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR);
   }
 
   public void test_finalAndVar() throws Exception {
     parse("parseClassMember", new Object[] {"C"}, "final var x;", ParserErrorCode.FINAL_AND_VAR);
   }
 
   public void test_finalClass() throws Exception {
-    parse("parseCompilationUnit", "final class C {}", ParserErrorCode.FINAL_CLASS);
+    parseCompilationUnit("final class C {}", ParserErrorCode.FINAL_CLASS);
   }
 
   public void test_finalConstructor() throws Exception {
     parse("parseClassMember", new Object[] {"C"}, "final C() {}", ParserErrorCode.FINAL_CONSTRUCTOR);
   }
 
   public void test_finalMethod() throws Exception {
     parse("parseClassMember", new Object[] {"C"}, "final int m() {}", ParserErrorCode.FINAL_METHOD);
   }
 
   public void test_finalTypedef() throws Exception {
-    parse("parseCompilationUnit", "final typedef F();", ParserErrorCode.FINAL_TYPEDEF);
+    parseCompilationUnit("final typedef F();", ParserErrorCode.FINAL_TYPEDEF);
   }
 
   public void test_getterWithParameters() throws Exception {
     parse(
         "parseClassMember",
         new Object[] {"C"},
         "int get x() {}",
         ParserErrorCode.GETTER_WITH_PARAMETERS);
   }
 
   public void test_illegalAssignmentToNonAssignable_superAssigned() throws Exception {
     // TODO(brianwilkerson) When the test fail_illegalAssignmentToNonAssignable_superAssigned starts
     // to pass, remove this test (there should only be one error generated, but we're keeping this
     // test until that time so that we can catch other forms of regressions).
-    parse(
-        "parseExpression",
+    parseExpression(
         "super = x;",
         ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR,
         ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE);
   }
 
   public void test_implementsBeforeExtends() throws Exception {
-    parse(
-        "parseCompilationUnit",
+    parseCompilationUnit(
         "class A implements B extends C {}",
         ParserErrorCode.IMPLEMENTS_BEFORE_EXTENDS);
   }
 
   public void test_implementsBeforeWith() throws Exception {
-    parse(
-        "parseCompilationUnit",
+    parseCompilationUnit(
         "class A extends B implements C with D {}",
         ParserErrorCode.IMPLEMENTS_BEFORE_WITH);
   }
 
   public void test_importDirectiveAfterPartDirective() throws Exception {
-    parse(
-        "parseCompilationUnit",
+    parseCompilationUnit(
         "part 'a.dart'; import 'b.dart';",
         ParserErrorCode.IMPORT_DIRECTIVE_AFTER_PART_DIRECTIVE);
   }
 
   public void test_initializedVariableInForEach() throws Exception {
     parse(
         "parseForStatement",
         "for (int a = 0 in foo) {}",
         ParserErrorCode.INITIALIZED_VARIABLE_IN_FOR_EACH);
   }
@@ skipping 44 matching lines @@
 
   public void test_invalidUnicodeEscape_tooManyDigits_variable() throws Exception {
     parse(
         "parseStringLiteral",
         "'\\u{12345678}'",
         ParserErrorCode.INVALID_UNICODE_ESCAPE,
         ParserErrorCode.INVALID_CODE_POINT);
   }
 
   public void test_libraryDirectiveNotFirst() throws Exception {
-    parse(
-        "parseCompilationUnit",
-        "import 'x.dart'; library l;",
-        ParserErrorCode.LIBRARY_DIRECTIVE_NOT_FIRST);
+    parseCompilationUnit("import 'x.dart'; library l;", ParserErrorCode.LIBRARY_DIRECTIVE_NOT_FIRST);
   }
 
   public void test_libraryDirectiveNotFirst_afterPart() throws Exception {
-    CompilationUnit unit = parse(
-        "parseCompilationUnit",
+    CompilationUnit unit = parseCompilationUnit(
         "part 'a.dart';\nlibrary l;",
         ParserErrorCode.LIBRARY_DIRECTIVE_NOT_FIRST);
     assertNotNull(unit);
   }
 
   public void test_missingAssignableSelector_identifiersAssigned() throws Exception {
-    parse("parseExpression", "x.y = y;");
+    parseExpression("x.y = y;");
   }
 
   public void test_missingAssignableSelector_primarySelectorPostfix() throws Exception {
-    parse("parseExpression", "x(y)(z)++", ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR);
+    parseExpression("x(y)(z)++", ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR);
   }
 
   public void test_missingAssignableSelector_selector() throws Exception {
-    parse("parseExpression", "x(y)(z).a++");
+    parseExpression("x(y)(z).a++");
   }
 
   public void test_missingAssignableSelector_superPrimaryExpression() throws Exception {
     SuperExpression expression = parse(
         "parsePrimaryExpression",
         "super",
         ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR);
     assertNotNull(expression.getKeyword());
   }
 
   public void test_missingAssignableSelector_superPropertyAccessAssigned() throws Exception {
-    parse("parseExpression", "super.x = x;");
+    parseExpression("super.x = x;");
   }
 
   public void test_missingCatchOrFinally() throws Exception {
     TryStatement statement = parse(
         "parseTryStatement",
         "try {}",
         ParserErrorCode.MISSING_CATCH_OR_FINALLY);
     assertNotNull(statement);
   }
 
   public void test_missingClassBody() throws Exception {
-    parse("parseCompilationUnit", "class A class B {}", ParserErrorCode.MISSING_CLASS_BODY);
+    parseCompilationUnit("class A class B {}", ParserErrorCode.MISSING_CLASS_BODY);
   }
 
   public void test_missingConstFinalVarOrType() throws Exception {
     parse(
         "parseFinalConstVarOrType",
         new Object[] {false},
         "a;",
         ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE);
   }
 
   public void test_missingFunctionBody_emptyNotAllowed() throws Exception {
     parse(
         "parseFunctionBody",
         new Object[] {false, false},
         ";",
         ParserErrorCode.MISSING_FUNCTION_BODY);
   }
 
   public void test_missingFunctionBody_invalid() throws Exception {
     parse(
         "parseFunctionBody",
         new Object[] {false, false},
         "return 0;",
         ParserErrorCode.MISSING_FUNCTION_BODY);
   }
 
   public void test_missingFunctionParameters_local_void_block() throws Exception {
-    parse("parseStatement", "void f { return x;}", ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
+    parseStatement("void f { return x;}", ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
   }
 
   public void test_missingFunctionParameters_local_void_expression() throws Exception {
-    parse("parseStatement", "void f => x;", ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
+    parseStatement("void f => x;", ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
   }
 
   public void test_missingFunctionParameters_topLevel_nonVoid_block() throws Exception {
-    parse("parseCompilationUnit", "int f { return x;}", ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
+    parseCompilationUnit("int f { return x;}", ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
   }
 
   public void test_missingFunctionParameters_topLevel_nonVoid_expression() throws Exception {
-    parse("parseCompilationUnit", "int f => x;", ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
+    parseCompilationUnit("int f => x;", ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
   }
 
   public void test_missingFunctionParameters_topLevel_void_block() throws Exception {
-    parse(
-        "parseCompilationUnit",
-        "void f { return x;}",
-        ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
+    parseCompilationUnit("void f { return x;}", ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
   }
 
   public void test_missingFunctionParameters_topLevel_void_expression() throws Exception {
-    parse("parseCompilationUnit", "void f => x;", ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
+    parseCompilationUnit("void f => x;", ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
   }
 
   public void test_missingIdentifier_functionDeclaration_returnTypeWithoutName() throws Exception {
     parse("parseFunctionDeclarationStatement", "A<T> () {}", ParserErrorCode.MISSING_IDENTIFIER);
   }
 
   public void test_missingIdentifier_number() throws Exception {
     SimpleIdentifier expression = parse(
         "parseSimpleIdentifier",
         "1",
         ParserErrorCode.MISSING_IDENTIFIER);
     assertTrue(expression.isSynthetic());
   }
 
   public void test_missingKeywordOperator() throws Exception {
     parse(
         "parseOperator",
         new Object[] {emptyCommentAndMetadata(), null, null},
         "+(x) {}",
         ParserErrorCode.MISSING_KEYWORD_OPERATOR);
   }
 
   public void test_missingNameInLibraryDirective() throws Exception {
-    CompilationUnit unit = parse(
-        "parseCompilationUnit",
+    CompilationUnit unit = parseCompilationUnit(
         "library;",
         ParserErrorCode.MISSING_NAME_IN_LIBRARY_DIRECTIVE);
     assertNotNull(unit);
   }
 
   public void test_missingNameInPartOfDirective() throws Exception {
-    CompilationUnit unit = parse(
-        "parseCompilationUnit",
+    CompilationUnit unit = parseCompilationUnit(
         "part of;",
         ParserErrorCode.MISSING_NAME_IN_PART_OF_DIRECTIVE);
     assertNotNull(unit);
   }
 
   public void test_missingTerminatorForParameterGroup_named() throws Exception {
     parse(
         "parseFormalParameterList",
         "(a, {b: 0)",
         ParserErrorCode.MISSING_TERMINATOR_FOR_PARAMETER_GROUP);
   }
 
   public void test_missingTerminatorForParameterGroup_optional() throws Exception {
     parse(
         "parseFormalParameterList",
         "(a, [b = 0)",
         ParserErrorCode.MISSING_TERMINATOR_FOR_PARAMETER_GROUP);
   }
 
   public void test_missingTypedefParameters_nonVoid() throws Exception {
-    parse("parseCompilationUnit", "typedef int F;", ParserErrorCode.MISSING_TYPEDEF_PARAMETERS);
+    parseCompilationUnit("typedef int F;", ParserErrorCode.MISSING_TYPEDEF_PARAMETERS);
   }
 
   public void test_missingTypedefParameters_typeParameters() throws Exception {
-    parse("parseCompilationUnit", "typedef F<E>;", ParserErrorCode.MISSING_TYPEDEF_PARAMETERS);
+    parseCompilationUnit("typedef F<E>;", ParserErrorCode.MISSING_TYPEDEF_PARAMETERS);
   }
 
   public void test_missingTypedefParameters_void() throws Exception {
-    parse("parseCompilationUnit", "typedef void F;", ParserErrorCode.MISSING_TYPEDEF_PARAMETERS);
+    parseCompilationUnit("typedef void F;", ParserErrorCode.MISSING_TYPEDEF_PARAMETERS);
   }
 
   public void test_missingVariableInForEach() throws Exception {
     parse(
         "parseForStatement",
         "for (a < b in foo) {}",
         ParserErrorCode.MISSING_VARIABLE_IN_FOR_EACH);
   }
 
   public void test_mixedParameterGroups_namedPositional() throws Exception {
     parse("parseFormalParameterList", "(a, {b}, [c])", ParserErrorCode.MIXED_PARAMETER_GROUPS);
   }
 
   public void test_mixedParameterGroups_positionalNamed() throws Exception {
     parse("parseFormalParameterList", "(a, [b], {c})", ParserErrorCode.MIXED_PARAMETER_GROUPS);
   }
 
   public void test_multipleLibraryDirectives() throws Exception {
-    parse(
-        "parseCompilationUnit",
-        "library l; library m;",
-        ParserErrorCode.MULTIPLE_LIBRARY_DIRECTIVES);
+    parseCompilationUnit("library l; library m;", ParserErrorCode.MULTIPLE_LIBRARY_DIRECTIVES);
   }
 
   public void test_multipleNamedParameterGroups() throws Exception {
     parse(
         "parseFormalParameterList",
         "(a, {b}, {c})",
         ParserErrorCode.MULTIPLE_NAMED_PARAMETER_GROUPS);
   }
 
   public void test_multiplePartOfDirectives() throws Exception {
-    parse(
-        "parseCompilationUnit",
-        "part of l; part of m;",
-        ParserErrorCode.MULTIPLE_PART_OF_DIRECTIVES);
+    parseCompilationUnit("part of l; part of m;", ParserErrorCode.MULTIPLE_PART_OF_DIRECTIVES);
   }
 
   public void test_multiplePositionalParameterGroups() throws Exception {
     parse(
         "parseFormalParameterList",
         "(a, [b], [c])",
         ParserErrorCode.MULTIPLE_POSITIONAL_PARAMETER_GROUPS);
   }
 
   public void test_multipleVariablesInForEach() throws Exception {
@@ skipping 17 matching lines @@
 
   public void test_nonConstructorFactory_method() throws Exception {
     parse(
         "parseClassMember",
         new Object[] {"C"},
         "factory int m() {}",
         ParserErrorCode.NON_CONSTRUCTOR_FACTORY);
   }
 
   public void test_nonIdentifierLibraryName_library() throws Exception {
-    CompilationUnit unit = parse(
-        "parseCompilationUnit",
+    CompilationUnit unit = parseCompilationUnit(
         "library 'lib';",
         ParserErrorCode.NON_IDENTIFIER_LIBRARY_NAME);
     assertNotNull(unit);
   }
 
   public void test_nonIdentifierLibraryName_partOf() throws Exception {
-    CompilationUnit unit = parse(
-        "parseCompilationUnit",
+    CompilationUnit unit = parseCompilationUnit(
         "part of 'lib';",
         ParserErrorCode.NON_IDENTIFIER_LIBRARY_NAME);
     assertNotNull(unit);
   }
 
   public void test_nonPartOfDirectiveInPart_after() throws Exception {
-    parse(
-        "parseCompilationUnit",
-        "part of l; part 'f.dart';",
-        ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART);
+    parseCompilationUnit("part of l; part 'f.dart';", ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART);
   }
 
   public void test_nonPartOfDirectiveInPart_before() throws Exception {
-    parse(
-        "parseCompilationUnit",
-        "part 'f.dart'; part of m;",
-        ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART);
+    parseCompilationUnit("part 'f.dart'; part of m;", ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART);
   }
 
   public void test_nonUserDefinableOperator() throws Exception {
     parse(
         "parseClassMember",
         new Object[] {"C"},
         "operator +=(int x) => x + 1;",
         ParserErrorCode.NON_USER_DEFINABLE_OPERATOR);
   }
 
@@ skipping 46 matching lines @@
 
   public void test_staticOperator_returnType() throws Exception {
     parse(
         "parseClassMember",
         new Object[] {"C"},
         "static int operator +(int x) => x + 1;",
         ParserErrorCode.STATIC_OPERATOR);
   }
 
   public void test_staticTopLevelDeclaration_class() throws Exception {
-    parse("parseCompilationUnit", "static class C {}", ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION);
+    parseCompilationUnit("static class C {}", ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION);
   }
 
   public void test_staticTopLevelDeclaration_typedef() throws Exception {
-    parse(
-        "parseCompilationUnit",
-        "static typedef F();",
-        ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION);
+    parseCompilationUnit("static typedef F();", ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION);
   }
 
   public void test_staticTopLevelDeclaration_variable() throws Exception {
-    parse("parseCompilationUnit", "static var x;", ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION);
+    parseCompilationUnit("static var x;", ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION);
   }
 
   public void test_switchHasCaseAfterDefaultCase() throws Exception {
     parse(
         "parseSwitchStatement",
         "switch (a) {default: return 0; case 1: return 1;}",
         ParserErrorCode.SWITCH_HAS_CASE_AFTER_DEFAULT_CASE);
   }
 
   public void test_switchHasCaseAfterDefaultCase_repeated() throws Exception {
@@ skipping 59 matching lines @@
 
   public void test_unexpectedToken_semicolonBetweenClassMembers() throws Exception {
     parse(
         "parseClassDeclaration",
         new Object[] {emptyCommentAndMetadata(), null},
         "class C { int x; ; int y;}",
         ParserErrorCode.UNEXPECTED_TOKEN);
   }
 
   public void test_unexpectedToken_semicolonBetweenCompilationUnitMembers() throws Exception {
-    parse("parseCompilationUnit", "int x; ; int y;", ParserErrorCode.UNEXPECTED_TOKEN);
+    parseCompilationUnit("int x; ; int y;", ParserErrorCode.UNEXPECTED_TOKEN);
   }
 
   public void test_useOfUnaryPlusOperator() throws Exception {
     parse("parseUnaryExpression", "+x", ParserErrorCode.USE_OF_UNARY_PLUS_OPERATOR);
   }
 
+  public void test_varAsTypeName_as() throws Exception {
+    parseExpression("x as var", ParserErrorCode.VAR_AS_TYPE_NAME);
+  }
+
   public void test_varClass() throws Exception {
-    parse("parseCompilationUnit", "var class C {}", ParserErrorCode.VAR_CLASS);
+    parseCompilationUnit("var class C {}", ParserErrorCode.VAR_CLASS);
   }
 
   public void test_varConstructor() throws Exception {
     parse(
         "parseClassMember",
         new Object[] {"C"},
         "var C() {}",
         ParserErrorCode.CONSTRUCTOR_WITH_RETURN_TYPE);
   }
 
   public void test_varReturnType() throws Exception {
     parse("parseClassMember", new Object[] {"C"}, "var m() {}", ParserErrorCode.VAR_RETURN_TYPE);
   }
 
   public void test_varTypedef() throws Exception {
-    parse("parseCompilationUnit", "var typedef F();", ParserErrorCode.VAR_TYPEDEF);
+    parseCompilationUnit("var typedef F();", ParserErrorCode.VAR_TYPEDEF);
   }
 
   public void test_voidField_initializer() throws Exception {
     parse("parseClassMember", new Object[] {"C"}, "void x = 0;", ParserErrorCode.VOID_VARIABLE);
   }
 
   public void test_voidField_noInitializer() throws Exception {
     parse("parseClassMember", new Object[] {"C"}, "void x;", ParserErrorCode.VOID_VARIABLE);
   }
 
   public void test_voidParameter() throws Exception {
     parse("parseNormalFormalParameter", "void a)", ParserErrorCode.VOID_PARAMETER);
   }
 
   public void test_withBeforeExtends() throws Exception {
-    parse(
-        "parseCompilationUnit",
-        "class A with B extends C {}",
-        ParserErrorCode.WITH_BEFORE_EXTENDS);
+    parseCompilationUnit("class A with B extends C {}", ParserErrorCode.WITH_BEFORE_EXTENDS);
   }
 
   public void test_withWithoutExtends() throws Exception {
     parse(
         "parseClassDeclaration",
         new Object[] {emptyCommentAndMetadata(), null},
         "class A with B, C {}",
         ParserErrorCode.WITH_WITHOUT_EXTENDS);
   }
 
@@ skipping 18 matching lines @@
         ParserErrorCode.WRONG_TERMINATOR_FOR_PARAMETER_GROUP);
   }
 
   public void test_wrongTerminatorForParameterGroup_optional() throws Exception {
     parse(
         "parseFormalParameterList",
         "(a, [b, c})",
         ParserErrorCode.WRONG_TERMINATOR_FOR_PARAMETER_GROUP);
   }
 }