Reapply "Tweak public APIs and use them in patch_sdk, dart2js, and kernel-service.""

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 ProcedureKind;
 
 import '../fasta_codes.dart' show FastaMessage, codeExpectedBlockToSkip;
 
@@ skipping 10 matching lines @@
 import '../errors.dart' show internalError;
 
 import '../builder/builder.dart';
 
 import '../modifier.dart' show abstractMask, externalMask, Modifier;
 
 import 'source_library_builder.dart' show SourceLibraryBuilder;
 
 import 'unhandled_listener.dart' show NullValue, Unhandled, UnhandledListener;
 
-import '../parser/dart_vm_native.dart' show removeNativeClause;
+import '../parser/native_support.dart'
+    show extractNativeMethodName, removeNativeClause, skipNativeClause;
 
 import '../operator.dart'
     show
         Operator,
         operatorFromString,
         operatorToString,
         operatorRequiredArgumentCount;
 
 import '../quote.dart' show unescapeString;
 
 enum MethodBody {
   Abstract,
   Regular,
   RedirectingFactoryBody,
 }
 
 class OutlineBuilder extends UnhandledListener {
   final SourceLibraryBuilder library;
 
   final bool enableNative;
+  final bool stringExpectedAfterNative;
 
   /// When true, recoverable parser errors are silently ignored. This is
   /// because they will be reported by the BodyBuilder later. However, typedefs
   /// are fully compiled by the outline builder, so parser errors are turned on
   /// when parsing typedefs.
   bool silenceParserErrors = true;
 
   String nativeMethodName;
 
   OutlineBuilder(SourceLibraryBuilder library)
       : library = library,
-        enableNative = library.loader.target.enableNative(library);
+        enableNative =
+            library.loader.target.backendTarget.enableNative(library.uri),
+        stringExpectedAfterNative =
+            library.loader.target.backendTarget.nativeExtensionExpectsString;
 
   @override
   Uri get uri => library.fileUri;
 
   @override
   int popCharOffset() => pop();
 
   List<String> popIdentifierList(int count) {
     if (count == 0) return null;
     List<String> list = new List<String>.filled(count, null, growable: true);
@@ skipping 768 matching lines @@
     if (silenceParserErrors) {
       debugEvent("RecoverableError");
     } else {
       super.handleRecoverableError(token, message);
     }
   }
 
   @override
   Token handleUnrecoverableError(Token token, FastaMessage message) {
     if (enableNative && message.code == codeExpectedBlockToSkip) {
-      var target = library.loader.target;
-      Token recover = target.skipNativeClause(token);
+      Token recover = skipNativeClause(token, stringExpectedAfterNative);
       if (recover != null) {
-        nativeMethodName = target.extractNativeMethodName(token);
+        nativeMethodName =
+            stringExpectedAfterNative ? extractNativeMethodName(token) : "";
         return recover;
       }
     }
     return super.handleUnrecoverableError(token, message);
   }
 
   @override
   void addCompileTimeErrorFromMessage(FastaMessage message) {
     library.addCompileTimeError(message.charOffset, message.message,
         fileUri: message.uri);
   }
 
   @override
   Link<Token> handleMemberName(Link<Token> identifiers) {
     if (!enableNative || identifiers.isEmpty) return identifiers;
-    return removeNativeClause(identifiers);
+    return removeNativeClause(identifiers, stringExpectedAfterNative);
   }
 
   @override
   void debugEvent(String name) {
     // printEvent(name);
   }
 }