Improve error recovery when using 'var' as a type

editor/tools/plugins/com.google.dart.engine_test/src/com/google/dart/engine/parser/RecoveryParserTest.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 265 matching lines @@
     assertTrue(expression.getRightOperand().isSynthetic());
   }
 
   public void test_equalityExpression_missing_RHS_super() throws Exception {
     BinaryExpression expression = parseExpression("super ==");
     assertInstanceOf(SimpleIdentifier.class, expression.getRightOperand());
     assertTrue(expression.getRightOperand().isSynthetic());
   }
 
   public void test_equalityExpression_precedence_relational_left() throws Exception {
-    BinaryExpression expression = parseExpression("is ==", ParserErrorCode.MISSING_IDENTIFIER);
+    BinaryExpression expression = parseExpression("is ==", ParserErrorCode.EXPECTED_TYPE_NAME);
     assertInstanceOf(IsExpression.class, expression.getLeftOperand());
   }
 
   public void test_equalityExpression_precedence_relational_right() throws Exception {
-    BinaryExpression expression = parseExpression("== is", ParserErrorCode.MISSING_IDENTIFIER);
+    BinaryExpression expression = parseExpression("== is", ParserErrorCode.EXPECTED_TYPE_NAME);
     assertInstanceOf(IsExpression.class, expression.getRightOperand());
   }
 
   public void test_equalityExpression_super() throws Exception {
     BinaryExpression expression = parseExpression("super ==  ==");
     assertInstanceOf(BinaryExpression.class, expression.getLeftOperand());
   }
 
   public void test_expressionList_multiple_end() throws Exception {
     List<Expression> result = parse("parseExpressionList", ", 2, 3, 4");
@@ skipping 15 matching lines @@
     List<Expression> result = parse("parseExpressionList", "1, 2, 3,");
     assertSize(4, result);
     Expression syntheticExpression = result.get(3);
     assertInstanceOf(SimpleIdentifier.class, syntheticExpression);
     assertTrue(syntheticExpression.isSynthetic());
   }
 
   public void test_isExpression_noType() throws Exception {
     CompilationUnit unit = parseCompilationUnit(
         "class Bar<T extends Foo> {m(x){if (x is ) return;if (x is !)}}",
-        ParserErrorCode.MISSING_IDENTIFIER,
-        ParserErrorCode.MISSING_IDENTIFIER,
+        ParserErrorCode.EXPECTED_TYPE_NAME,
+        ParserErrorCode.EXPECTED_TYPE_NAME,
         ParserErrorCode.MISSING_STATEMENT);
     ClassDeclaration declaration = (ClassDeclaration) unit.getDeclarations().get(0);
     MethodDeclaration method = (MethodDeclaration) declaration.getMembers().get(0);
     BlockFunctionBody body = (BlockFunctionBody) method.getBody();
     IfStatement ifStatement = (IfStatement) body.getBlock().getStatements().get(1);
     IsExpression expression = (IsExpression) ifStatement.getCondition();
     assertNotNull(expression.getExpression());
     assertNotNull(expression.getIsOperator());
     assertNotNull(expression.getNotOperator());
     TypeName type = expression.getType();
@@ skipping 110 matching lines @@
     assertEquals(TokenType.MINUS, expression.getOperator().getType());
   }
 
   public void test_relationalExpression_missing_LHS() throws Exception {
     IsExpression expression = parseExpression("is y");
     assertInstanceOf(SimpleIdentifier.class, expression.getExpression());
     assertTrue(expression.getExpression().isSynthetic());
   }
 
   public void test_relationalExpression_missing_LHS_RHS() throws Exception {
-    IsExpression expression = parseExpression("is", ParserErrorCode.MISSING_IDENTIFIER);
+    IsExpression expression = parseExpression("is", ParserErrorCode.EXPECTED_TYPE_NAME);
     assertInstanceOf(SimpleIdentifier.class, expression.getExpression());
     assertTrue(expression.getExpression().isSynthetic());
     assertInstanceOf(TypeName.class, expression.getType());
     assertTrue(expression.getType().isSynthetic());
   }
 
   public void test_relationalExpression_missing_RHS() throws Exception {
-    IsExpression expression = parseExpression("x is", ParserErrorCode.MISSING_IDENTIFIER);
+    IsExpression expression = parseExpression("x is", ParserErrorCode.EXPECTED_TYPE_NAME);
     assertInstanceOf(TypeName.class, expression.getType());
     assertTrue(expression.getType().isSynthetic());
   }
 
   public void test_relationalExpression_precedence_shift_right() throws Exception {
-    IsExpression expression = parseExpression("<< is", ParserErrorCode.MISSING_IDENTIFIER);
+    IsExpression expression = parseExpression("<< is", ParserErrorCode.EXPECTED_TYPE_NAME);
     assertInstanceOf(BinaryExpression.class, expression.getExpression());
   }
 
   public void test_shiftExpression_missing_LHS() throws Exception {
     BinaryExpression expression = parseExpression("<< y");
     assertInstanceOf(SimpleIdentifier.class, expression.getLeftOperand());
     assertTrue(expression.getLeftOperand().isSynthetic());
   }
 
   public void test_shiftExpression_missing_LHS_RHS() throws Exception {
@@ skipping 39 matching lines @@
     CompilationUnit unit = parseCompilationUnit(
         "typedef n",
         ParserErrorCode.EXPECTED_TOKEN,
         ParserErrorCode.MISSING_TYPEDEF_PARAMETERS);
     NodeList<CompilationUnitMember> declarations = unit.getDeclarations();
     assertSize(1, declarations);
     CompilationUnitMember member = declarations.get(0);
     assertInstanceOf(FunctionTypeAlias.class, member);
   }
 }