support class native clause

pkg/analyzer/lib/src/fasta/ast_builder.dart

 // Copyright (c) 2016, 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 fasta.analyzer.ast_builder;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast_factory.dart' show AstFactory;
 import 'package:analyzer/dart/ast/standard_ast_factory.dart' as standard;
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
@@ skipping 13 matching lines @@
 import 'package:front_end/src/fasta/messages.dart'
     show Code, Message, codeExpectedExpression, codeExpectedFunctionBody;
 import 'package:front_end/src/fasta/kernel/kernel_builder.dart'
     show Builder, KernelLibraryBuilder, Scope;
 import 'package:front_end/src/fasta/quote.dart';
 import 'package:front_end/src/fasta/source/scope_listener.dart'
     show JumpTargetKind, NullValue, ScopeListener;
 import 'package:analyzer/src/dart/error/syntactic_errors.dart';
 
 class AstBuilder extends ScopeListener {
+  /// The native clause in class, method, and function declarations
+  /// is being replaced by the @native(...) annotation.
+  static bool isNativeClauseAllowed = true;

[ahe, 2017/08/21 12:04:10]

I think this should only be true if:

* The current library is a platform library.

* The current library has an import that uses the scheme "dart-ext".

Those two properties could be left as a todo.

More importantly, this shouldn't be a static field and I've added a suggestion
for how to avoid that in parser_fasta_test.dart.

[danrubel, 2017/08/22 01:35:27]

Good point. Cleaned up and added TODO per discussion.

+
   final AstFactory ast = standard.astFactory;
 
   final ErrorReporter errorReporter;
   final KernelLibraryBuilder library;
   final Builder member;
 
   ScriptTag scriptTag;
   final List<Directive> directives = <Directive>[];
   final List<CompilationUnitMember> declarations = <CompilationUnitMember>[];
 
@@ skipping 1233 matching lines @@
     className = name.lexeme;
   }
 
   @override
   void endClassDeclaration(
       int interfacesCount,
       Token beginToken,
       Token classKeyword,
       Token extendsKeyword,
       Token implementsKeyword,
+      Token nativeToken,
       Token endToken) {
     debugEvent("ClassDeclaration");
     _ClassBody body = pop();
+    NativeClause nativeClause;
+    if (nativeToken?.next?.type == TokenType.STRING) {

[ahe, 2017/08/21 12:04:10]

This feels like implementing parser logic in the listener.

What I would expect is this:

if (nativeToken != null) {
  nativeClause = pop();
}

[danrubel, 2017/08/22 01:35:27]

I was trying for the simplest thing given that this functionality will be
replaced by @native(...) in future. That said, I like your suggestion of adding
a new nativeClause event. With that new event, this expression reverts back to
the simple null check that I previously had.

+      nativeClause = ast.nativeClause(nativeToken, pop());
+    }
     ImplementsClause implementsClause;
     if (implementsKeyword != null) {
       List<TypeName> interfaces = popList(interfacesCount);
       implementsClause = ast.implementsClause(implementsKeyword, interfaces);
     }
     ExtendsClause extendsClause;
     WithClause withClause;
     var supertype = pop();
     if (supertype == null) {
       // No extends clause
     } else if (supertype is TypeName) {
       extendsClause = ast.extendsClause(extendsKeyword, supertype);
     } else if (supertype is _MixinApplication) {
       extendsClause = ast.extendsClause(extendsKeyword, supertype.supertype);
       withClause = ast.withClause(supertype.withKeyword, supertype.mixinTypes);
     } else {
       unhandled("${supertype.runtimeType}", "supertype",
           extendsKeyword.charOffset, uri);
     }
     TypeParameterList typeParameters = pop();
     SimpleIdentifier name = pop();
     assert(className == name.name);
     className = null;
     _Modifiers modifiers = pop();
     Token abstractKeyword = modifiers?.abstractKeyword;
     List<Annotation> metadata = pop();
     Comment comment = pop();
-    declarations.add(ast.classDeclaration(
+    ClassDeclaration classDeclaration = ast.classDeclaration(
         comment,
         metadata,
         abstractKeyword,
         classKeyword,
         name,
         typeParameters,
         extendsClause,
         withClause,
         implementsClause,
         body.beginToken,
         body.members,
-        body.endToken));
+        body.endToken);
+    classDeclaration.nativeClause = nativeClause;
+    declarations.add(classDeclaration);
   }
 
   @override
   void endMixinApplication(Token withKeyword) {
     debugEvent("MixinApplication");
     List<TypeName> mixinTypes = pop();
     TypeName supertype = pop();
     push(new _MixinApplication(supertype, withKeyword, mixinTypes));
   }
 
@@ skipping 544 matching lines @@
 
   @override
   void addCompileTimeError(Message message, int charOffset) {
     Code code = message.code;
     Map<String, dynamic> arguments = message.arguments;
     switch (code.analyzerCode) {
       case "EXPECTED_TYPE_NAME":
         errorReporter?.reportErrorForOffset(
             ParserErrorCode.EXPECTED_TYPE_NAME, charOffset, 1);
         return;
+      case "NATIVE_CLAUSE_SHOULD_BE_ANNOTATION":
+        if (!isNativeClauseAllowed) {
+          errorReporter?.reportErrorForOffset(
+              ParserErrorCode.NATIVE_CLAUSE_SHOULD_BE_ANNOTATION,
+              charOffset,
+              1);
+        }
+        return;
       case "EXPECTED_STRING_LITERAL":
         errorReporter?.reportErrorForOffset(
             ParserErrorCode.EXPECTED_STRING_LITERAL, charOffset, 1);
         return;
       case "UNEXPECTED_TOKEN":
         var text = arguments['string'];
         if (text == null) {
           Token token = arguments['token'];
           if (token != null) {
             text = token.lexeme;
@@ skipping 107 matching lines @@
       } else if (identical('var', s)) {
         finalConstOrVarKeyword = token;
       } else if (identical('covariant', s)) {
         covariantKeyword = token;
       } else {
         unhandled("$s", "modifier", token.charOffset, null);
       }
     }
   }
 }