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

pkg/front_end/lib/src/fasta/kernel/body_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.body_builder;
 
 import '../fasta_codes.dart'
     show
         FastaMessage,
         codeConstFieldWithoutInitializer,
         codeExpectedButGot,
         codeExpectedFunctionBody,
         codeFinalFieldWithoutInitializer;
 
 import '../parser/parser.dart'
     show Assert, FormalParameterType, MemberKind, optional;
 
 import '../parser/identifier_context.dart' show IdentifierContext;
 
+import '../parser/native_support.dart' show skipNativeClause;
+
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart';
 
 import 'package:front_end/src/fasta/kernel/utils.dart' show offsetForToken;
 
 import 'package:front_end/src/fasta/type_inference/type_inferrer.dart'
     show TypeInferrer;
 
 import 'package:front_end/src/fasta/type_inference/type_promotion.dart'
     show TypePromoter;
 
@@ skipping 56 matching lines @@
 
   final ClassHierarchy hierarchy;
 
   final CoreTypes coreTypes;
 
   final bool isInstanceMember;
 
   final Scope enclosingScope;
 
   final bool enableNative;
+  final bool stringExpectedAfterNative;
 
   /// Whether to ignore an unresolved reference to `main` within the body of
   /// `_getMainClosure` when compiling the current library.
   ///
   /// This as a temporary workaround. The standalone VM and flutter have
   /// special logic to resolve `main` in `_getMainClosure`, this flag is used to
   /// ignore that reference to `main`, but only on libraries where we expect to
   /// see it (today that is dart:_builtin and dart:ui).
   ///
   // TODO(ahe,sigmund): remove when the VM gets rid of the special rule, see
@@ skipping 67 matching lines @@
       Scope scope,
       this.formalParameterScope,
       this.hierarchy,
       this.coreTypes,
       this.classBuilder,
       this.isInstanceMember,
       this.uri,
       this._typeInferrer)
       : enclosingScope = scope,
         library = library,
-        enableNative = library.loader.target.enableNative(library),
+        enableNative =
+            library.loader.target.backendTarget.enableNative(library.uri),
+        stringExpectedAfterNative =
+            library.loader.target.backendTarget.nativeExtensionExpectsString,
         ignoreMainInGetMainClosure = library.uri.scheme == 'dart' &&
             (library.uri.path == "_builtin" || library.uri.path == "ui"),
         needsImplicitSuperInitializer =
             coreTypes.objectClass != classBuilder?.cls,
         typePromoter = _typeInferrer.typePromoter,
         super(scope);
 
   bool get hasParserError => recoverableErrors.isNotEmpty;
 
   bool get inConstructor {
@@ skipping 2773 matching lines @@
   void handleRecoverableError(Token token, FastaMessage message) {
     bool silent = hasParserError ||
         message.code == codeFinalFieldWithoutInitializer ||
         message.code == codeConstFieldWithoutInitializer;
     addCompileTimeError(message.charOffset, message.message, silent: silent);
   }
 
   @override
   Token handleUnrecoverableError(Token token, FastaMessage message) {
     if (enableNative && message.code == codeExpectedFunctionBody) {
-      Token recover = library.loader.target.skipNativeClause(token);
+      Token recover = skipNativeClause(token, stringExpectedAfterNative);
       if (recover != null) return recover;
     } else if (message.code == codeExpectedButGot) {
       String expected = message.arguments["string"];
       const List<String> trailing = const <String>[")", "}", ";", ","];
       if (trailing.contains(token.stringValue) && trailing.contains(expected)) {
         handleRecoverableError(token, message);
         return newSyntheticToken(token);
       }
     }
     return super.handleUnrecoverableError(token, message);
@@ skipping 704 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return internalError("Unknown async modifier: $asyncToken");
   }
 }