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

pkg/front_end/lib/src/fasta/source/source_loader.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.source_loader;
 
 import 'dart:async' show Future;
 
 import 'dart:typed_data' show Uint8List;
 
@@ skipping 321 matching lines @@
     // will have the same length.
     Iterable<ClassBuilder> input = const [];
     Iterable<ClassBuilder> output = classes;
     while (input.length != output.length) {
       input = output;
       output = directSupertypes(input);
     }
     return output;
   }
 
+  /// Whether [library] is allowed to define classes that extend or implement
+  /// restricted types, such as `bool`, `int`, `double`, `num`, and `String`. By
+  /// default this is only allowed within the implementation of `dart:core`, but
+  /// some target implementations may need to override this to allow doing this
+  /// in other internal platform libraries.
+  bool canImplementRestrictedTypes(LibraryBuilder library) =>
+      library == coreLibrary;
+
   void checkSemantics() {
     List<ClassBuilder> allClasses = target.collectAllClasses();
     Iterable<ClassBuilder> candidates = cyclicCandidates(allClasses);
     Map<ClassBuilder, Set<ClassBuilder>> realCycles =
         <ClassBuilder, Set<ClassBuilder>>{};
     for (ClassBuilder cls in candidates) {
       Set<ClassBuilder> cycles = cyclicCandidates(allSupertypes(cls));
       if (cycles.isNotEmpty) {
         realCycles[cls] = cycles;
       }
@@ skipping 28 matching lines @@
     for (ClassBuilder cls in allClasses) {
       if (cls.library.loader != this) continue;
       Set<ClassBuilder> directSupertypes = new Set<ClassBuilder>();
       target.addDirectSupertype(cls, directSupertypes);
       for (ClassBuilder supertype in directSupertypes) {
         if (supertype is EnumBuilder) {
           cls.addCompileTimeError(
               cls.charOffset,
               "'${supertype.name}' is an enum and can't be extended or "
               "implemented.");
-        } else if (!cls.library.mayImplementRestrictedTypes &&
+        } else if (!canImplementRestrictedTypes(cls.library) &&
             blackListedClasses.contains(supertype)) {
           cls.addCompileTimeError(
               cls.charOffset,
               "'${supertype.name}' is restricted and can't be extended or "
               "implemented.");
         }
       }
       TypeBuilder mixedInType = cls.mixedInType;
       if (mixedInType != null) {
         bool isClassBuilder = false;
@@ skipping 111 matching lines @@
 
   Expression throwCompileConstantError(Expression error) {
     return target.backendTarget.throwCompileConstantError(coreTypes, error);
   }
 
   Expression buildCompileTimeError(String message, int offset) {
     return target.backendTarget
         .buildCompileTimeError(coreTypes, message, offset);
   }
 }