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 42 matching lines @@
   bool parseGenericMethodComments = false;
 
   /// The name of the class currently being parsed, or `null` if no class is
   /// being parsed.
   String className;
 
   /// If true, this is building a full AST. Otherwise, only create method
   /// bodies.
   final bool isFullAst;
 
+  /// `true` if the `native` clause is allowed
+  /// in class, method, and function declarations.
+  ///
+  /// This is being replaced by the @native(...) annotation.
+  //
+  // TODO(danrubel) Move this flag to a better location
+  // and should only be true if either:
+  // * The current library is a platform library
+  // * The current library has an import that uses the scheme "dart-ext".
+  bool allowNativeClause = false;
+
   AstBuilder(this.errorReporter, this.library, this.member, Scope scope,
       this.isFullAst,
       [Uri uri])
       : uri = uri ?? library.fileUri,
         super(scope);
 
   createJumpTarget(JumpTargetKind kind, int charOffset) {
     // TODO(ahe): Implement jump targets.
     return null;
   }
@@ skipping 1198 matching lines @@
         beginToken, popList(memberCount) ?? <ClassMember>[], endToken));
   }
 
   @override
   void beginClassDeclaration(Token beginToken, Token name) {
     assert(className == null);
     className = name.lexeme;
   }
 
   @override
+  void handleNativeClause(Token nativeToken, bool hasName) {
+    push(ast.nativeClause(nativeToken, hasName ? pop() : null));
+  }
+
+  @override
   void endClassDeclaration(
       int interfacesCount,
       Token beginToken,
       Token classKeyword,
       Token extendsKeyword,
       Token implementsKeyword,
+      Token nativeToken,
       Token endToken) {
     debugEvent("ClassDeclaration");
     _ClassBody body = pop();
+    NativeClause nativeClause = nativeToken != null ? pop() : null;
     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 (!allowNativeClause) {
+          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);
       }
     }
   }
 }