Annotate native methods.

pkg/front_end/lib/src/fasta/source/outline_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.outline_builder;
 
 import 'package:kernel/ast.dart' show
     AsyncMarker,
     ProcedureKind;
 
@@ skipping 31 matching lines @@
 
 import '../parser/dart_vm_native.dart' show
     removeNativeClause,
     skipNativeClause;
 
 import '../operator.dart' show
     Operator,
     operatorFromString,
     operatorToString;
 
+import '../quote.dart' show
+    unescapeString;
+
 enum MethodBody {
   Abstract,
   Regular,
   RedirectingFactoryBody,
 }
 
 AsyncMarker asyncMarkerFromTokens(Token asyncToken, Token starToken) {
   if (asyncToken == null || identical(asyncToken.stringValue, "sync")) {
     if (starToken == null) {
       return AsyncMarker.Sync;
@@ skipping 11 matching lines @@
   } else {
     return internalError("Unknown async modifier: $asyncToken");
   }
 }
 
 class OutlineBuilder extends UnhandledListener {
   final SourceLibraryBuilder library;
 
   final bool isDartLibrary;
 
+  String nativeMethodName;
+
   OutlineBuilder(SourceLibraryBuilder library)
       : library = library,
         isDartLibrary = library.uri.scheme == "dart";
 
   @override
   Uri get uri => library.uri;
 
   @override
   void endMetadata(Token beginToken, Token periodBeforeName, Token endToken) {
     debugEvent("Metadata");
@@ skipping 140 matching lines @@
     List<FormalParameterBuilder> formals = pop();
     List<TypeVariableBuilder> typeVariables = pop();
     String name = pop();
     TypeBuilder returnType = pop();
     int modifiers = Modifier.validate(pop(),
         isAbstract: kind == MethodBody.Abstract);
     List<MetadataBuilder> metadata = pop();
     checkEmpty();
     library.addProcedure(metadata, modifiers, returnType, name,
         typeVariables, formals, asyncModifier, computeProcedureKind(getOrSet),
-        beginToken.charOffset, isTopLevel: true);
+        beginToken.charOffset, nativeMethodName, isTopLevel: true);
+    nativeMethodName = null;
   }
 
   @override
   void handleNoFunctionBody(Token token) {
     debugEvent("NoFunctionBody");
     push(MethodBody.Abstract);
   }
 
   @override
   void handleFunctionBodySkipped(Token token) {
@@ skipping 28 matching lines @@
       kind = ProcedureKind.Operator;
     } else {
       name = nameOrOperator;
       kind = computeProcedureKind(getOrSet);
     }
     TypeBuilder returnType = pop();
     int modifiers = Modifier.validate(pop(),
         isAbstract: bodyKind == MethodBody.Abstract);
     List<MetadataBuilder> metadata = pop();
     library.addProcedure(metadata, modifiers, returnType, name, typeVariables,
-        formals, asyncModifier, kind, beginToken.charOffset, isTopLevel: false);
+        formals, asyncModifier, kind, beginToken.charOffset, nativeMethodName,
+        isTopLevel: false);
+    nativeMethodName = null;
   }
 
   @override
   void endMixinApplication() {
     debugEvent("MixinApplication");
     List<TypeBuilder> mixins = pop();
     TypeBuilder supertype = pop();
     push(library.addMixinApplication(supertype, mixins, -1));
   }
 
@@ skipping 207 matching lines @@
     MethodBody kind = pop();
     ConstructorReferenceBuilder redirectionTarget;
     if (kind == MethodBody.RedirectingFactoryBody) {
       redirectionTarget = pop();
     }
     AsyncMarker asyncModifier = pop();
     List<FormalParameterBuilder> formals = pop();
     var name = pop();
     List<MetadataBuilder> metadata = pop();
     library.addFactoryMethod(metadata, name, formals, asyncModifier,
-        redirectionTarget, beginToken.charOffset);
+        redirectionTarget, beginToken.charOffset, nativeMethodName);
+    nativeMethodName = null;
   }
 
   @override
   void endRedirectingFactoryBody(Token beginToken, Token endToken) {
     debugEvent("RedirectingFactoryBody");
     push(MethodBody.RedirectingFactoryBody);
   }
 
   @override
   void endFieldInitializer(Token assignmentOperator) {
@@ skipping 14 matching lines @@
 
   @override
   void handleNoInitializers() {
     debugEvent("NoInitializers");
     // This is a constructor initializer and it's ignored for now.
   }
 
   @override
   void endMember() {
     debugEvent("Member");
+    assert(nativeMethodName == null);
   }
 
   @override
   void endClassBody(int memberCount, Token beginToken, Token endToken) {
     debugEvent("ClassBody");
   }
 
   @override
   void handleAsyncModifier(Token asyncToken, Token starToken) {
     debugEvent("AsyncModifier");
     push(asyncMarkerFromTokens(asyncToken, starToken));
   }
 
   @override
   void handleModifier(Token token) {
     debugEvent("Modifier");
     push(new Modifier.fromString(token.stringValue));
   }
 
   @override
   void handleModifiers(int count) {
     debugEvent("Modifiers");
     push(popList(count) ?? NullValue.Modifiers);
   }
 
   @override
   Token handleUnrecoverableError(Token token, ErrorKind kind, Map arguments) {
     if (isDartLibrary && kind == ErrorKind.ExpectedBlockToSkip) {
       Token recover = skipNativeClause(token);
-      if (recover != null) return recover;
+      if (recover != null) {
+        nativeMethodName = unescapeString(token.next.value);
+        return recover;
+      }
     }
     return super.handleUnrecoverableError(token, kind, arguments);
   }
 
   @override
   Link<Token> handleMemberName(Link<Token> identifiers) {
     if (!isDartLibrary || identifiers.isEmpty) return identifiers;
     return removeNativeClause(identifiers);
   }
 
   @override
   void debugEvent(String name) {
     // printEvent(name);
   }
 }