Don't permit annotations inside variable declarations.

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.
 
 library engine.parser_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
@@ skipping 467 matching lines @@
     BinaryExpression expression = parseExpression("x << y + z");
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
         BinaryExpression, expression.rightOperand);
   }
 
   void test_shiftExpression_super() {
     BinaryExpression expression = parseExpression("super >> 4 << 3");
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression,
         BinaryExpression, expression.leftOperand);
   }
-
-  void test_topLevelVariable_withMetadata() {
-    ParserTestCase.parseCompilationUnit("String @A string;");
-  }
 }
 
 /**
  * The class `ErrorParserTest` defines parser tests that test the parsing of code to ensure
  * that errors are correctly reported, and in some cases, not reported.
  */
 @reflectiveTest
 class ErrorParserTest extends ParserTestCase {
   void fail_expectedListOrMapLiteral() {
     // It isn't clear that this test can ever pass. The parser is currently
@@ skipping 1390 matching lines @@
         "bool operator +(bool x, bool y) => x | y;",
         [ParserErrorCode.TOP_LEVEL_OPERATOR]);
   }
 
   void test_topLevelOperator_withVoid() {
     parse3("parseCompilationUnitMember", <Object>[emptyCommentAndMetadata()],
         "void operator +(bool x, bool y) => x | y;",
         [ParserErrorCode.TOP_LEVEL_OPERATOR]);
   }
 
+  void test_topLevelVariable_withMetadata() {
+    ParserTestCase.parseCompilationUnit("String @A string;", [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.EXPECTED_TOKEN,
+      ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE
+    ]);
+  }
+
   void test_typedefInClass_withoutReturnType() {
     ParserTestCase.parseCompilationUnit(
         "class C { typedef F(x); }", [ParserErrorCode.TYPEDEF_IN_CLASS]);
   }
 
   void test_typedefInClass_withReturnType() {
     ParserTestCase.parseCompilationUnit("class C { typedef int F(int x); }",
         [ParserErrorCode.TYPEDEF_IN_CLASS]);
   }
 
@@ skipping 1352 matching lines @@
     expect(vars, hasLength(1));
     expect(vars[0].name.name, "v");
   }
 
   void test_functionExpression_named() {
     parseExpression("m(f() => 0);", [ParserErrorCode.EXPECTED_TOKEN]);
   }
 
   void test_importDirectivePartial_as() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(
-        "import 'b.dart' d as b;",
-        [ParserErrorCode.UNEXPECTED_TOKEN]);
+        "import 'b.dart' d as b;", [ParserErrorCode.UNEXPECTED_TOKEN]);
     ImportDirective importDirective = unit.childEntities.first;
     expect(importDirective.asKeyword, isNotNull);
     expect(unit.directives, hasLength(1));
     expect(unit.declarations, hasLength(0));
   }
 
-  void test_importDirectivePartial_show() {
+  void test_importDirectivePartial_hide() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(
-        "import 'b.dart' d show foo;",
-        [ParserErrorCode.UNEXPECTED_TOKEN]);
+        "import 'b.dart' d hide foo;", [ParserErrorCode.UNEXPECTED_TOKEN]);
     ImportDirective importDirective = unit.childEntities.first;
     expect(importDirective.combinators, hasLength(1));
     expect(unit.directives, hasLength(1));
     expect(unit.declarations, hasLength(0));
   }
 
-  void test_importDirectivePartial_hide() {
+  void test_importDirectivePartial_show() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(
-        "import 'b.dart' d hide foo;",
-        [ParserErrorCode.UNEXPECTED_TOKEN]);
+        "import 'b.dart' d show foo;", [ParserErrorCode.UNEXPECTED_TOKEN]);
     ImportDirective importDirective = unit.childEntities.first;
     expect(importDirective.combinators, hasLength(1));
     expect(unit.directives, hasLength(1));
     expect(unit.declarations, hasLength(0));
   }
 
   void test_incomplete_conditionalExpression() {
     parseExpression("x ? 0", [
       ParserErrorCode.EXPECTED_TOKEN,
       ParserErrorCode.MISSING_IDENTIFIER
@@ skipping 6944 matching lines @@
         new Scanner(null, new CharSequenceReader(source), listener);
     Token tokenStream = scanner.tokenize();
     //
     // Parse the source.
     //
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(
         parser, methodName, <Object>[tokenStream], tokenStream) as Token;
   }
 }