support class native clause

pkg/analyzer/test/generated/parser_fasta_test.dart

 // Copyright (c) 2017, 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.
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' as analyzer;
+import 'package:analyzer/dart/ast/token.dart' show TokenType;
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart' show ErrorReporter;
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/fasta/ast_builder.dart';
 import 'package:analyzer/src/generated/parser.dart' as analyzer;
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/string_source.dart';
 import 'package:front_end/src/fasta/fasta_codes.dart' show Message;
 import 'package:front_end/src/fasta/kernel/kernel_builder.dart';
 import 'package:front_end/src/fasta/kernel/kernel_library_builder.dart';
@@ skipping 2190 matching lines @@
  * Implementation of [AbstractParserTestCase] specialized for testing the
  * Fasta parser.
  */
 class FastaParserTestCase extends Object
     with ParserTestHelpers
     implements AbstractParserTestCase {
   ParserProxy _parserProxy;
   analyzer.Token _fastaTokens;
 
   @override
+  bool allowNativeClause = false;
+
+  @override
   GatheringErrorListener get listener => _parserProxy._errorListener;
 
   /**
    * Whether generic method comments should be enabled for the test.
    */
   bool enableGenericMethodComments = false;
 
   @override
   set enableAssertInitializer(bool value) {
     if (value == true) {
@@ skipping 43 matching lines @@
   void assertNoErrors() {
     _parserProxy._errorListener.assertNoErrors();
   }
 
   @override
   void createParser(String content) {
     var scanner = new StringScanner(content, includeComments: true);
     scanner.scanGenericMethodComments = enableGenericMethodComments;
     _fastaTokens = scanner.tokenize();
     _parserProxy = new ParserProxy(_fastaTokens,
+        allowNativeClause: allowNativeClause,
         enableGenericMethodComments: enableGenericMethodComments);
   }
 
   @override
   void expectNotNullIfNoErrors(Object result) {
     if (!listener.hasErrors) {
       expect(result, isNotNull);
     }
   }
 
@@ skipping 476 matching lines @@
    */
   final GatheringErrorListener _errorListener;
 
   final ForwardingTestListener _eventListener;
 
   /**
    * Creates a [ParserProxy] which is prepared to begin parsing at the given
    * Fasta token.
    */
   factory ParserProxy(analyzer.Token startingToken,
-      {bool enableGenericMethodComments: false}) {
+      {bool allowNativeClause: false,
+      bool enableGenericMethodComments: false}) {
     var library = new KernelLibraryBuilderProxy();
     var member = new BuilderProxy();
     var scope = new ScopeProxy();
     TestSource source = new TestSource();
     var errorListener = new GatheringErrorListener();
     var errorReporter = new ErrorReporter(errorListener, source);
     var astBuilder =
         new AstBuilder(errorReporter, library, member, scope, true);
+    astBuilder.allowNativeClause = allowNativeClause;
     astBuilder.parseGenericMethodComments = enableGenericMethodComments;
     var eventListener = new ForwardingTestListener(astBuilder);
     var fastaParser = new fasta.Parser(eventListener);
     astBuilder.parser = fastaParser;
     return new ParserProxy._(
         startingToken, fastaParser, astBuilder, errorListener, eventListener);
   }
 
   ParserProxy._(this._currentFastaToken, this._fastaParser, this._astBuilder,
       this._errorListener, this._eventListener);
@@ skipping 131 matching lines @@
     super.test_parseTryStatement_on_catch_finally();
   }
 }
 
 /**
  * Tests of the fasta parser based on [TopLevelParserTestMixin].
  */
 @reflectiveTest
 class TopLevelParserTest_Fasta extends FastaParserTestCase
     with TopLevelParserTestMixin {
-  @override
-  @failingTest
-  void test_parseClassDeclaration_native() {
-    // TODO(paulberry): TODO(paulberry,ahe): Fasta parser doesn't appear to support "native" syntax yet.
-    super.test_parseClassDeclaration_native();
+  void test_parseClassDeclaration_native_missing_literal() {
+    createParser('class A native {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    if (allowNativeClause) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([
+        ParserErrorCode.NATIVE_CLAUSE_SHOULD_BE_ANNOTATION,
+      ]);
+    }
+    expect(member, new isInstanceOf<ClassDeclaration>());
+    ClassDeclaration declaration = member;
+    expect(declaration.nativeClause, isNotNull);
+    expect(declaration.nativeClause.nativeKeyword, isNotNull);
+    expect(declaration.nativeClause.name, isNull);
+    expect(declaration.endToken.type, TokenType.CLOSE_CURLY_BRACKET);
+  }
+
+  void test_parseClassDeclaration_native_allowed() {
+    allowNativeClause = true;
+    test_parseClassDeclaration_native();
+  }
+
+  void test_parseClassDeclaration_native_missing_literal_allowed() {
+    allowNativeClause = true;
+    test_parseClassDeclaration_native_missing_literal();
+  }
+
+  void test_parseClassDeclaration_native_missing_literal_not_allowed() {
+    allowNativeClause = false;
+    test_parseClassDeclaration_native_missing_literal();
+  }
+
+  void test_parseClassDeclaration_native_not_allowed() {
+    allowNativeClause = false;
+    test_parseClassDeclaration_native();
   }
 
   @override
   @failingTest
   void test_parseCompilationUnit_builtIn_asFunctionName() {
     // TODO(paulberry,ahe): Fasta's parser is confused when one of the built-in
     // identifiers `export`, `import`, `library`, `part`, or `typedef` appears
     // as the name of a top level function with an implicit return type.
     super.test_parseCompilationUnit_builtIn_asFunctionName();
   }
@@ skipping 36 matching lines @@
     assertNoErrors();
   }
 
   @failingTest
   void test_parseCompilationUnitMember_abstractAsPrefix2() {
     // TODO(danrubel): should not be generating an error
     super.test_parseCompilationUnitMember_abstractAsPrefix();
     assertNoErrors();
   }
 }