Read SDK and patches from a JSON file.

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, codeExpectedButGot, codeExpectedFunctionBody;
 
 import '../parser/parser.dart' show FormalParameterType, MemberKind, optional;
@@ skipping 75 matching lines @@
 
   final CoreTypes coreTypes;
 
   final bool isInstanceMember;
 
   final Map<String, FieldInitializer> fieldInitializers =
       <String, FieldInitializer>{};
 
   final Scope enclosingScope;
 
-  final bool isDartLibrary;
+  final bool enableNative;
 
   @override
   final Uri uri;
 
   final TypeInferrer _typeInferrer;
 
   @override
   final AstFactory astFactory;
 
   @override
@@ skipping 50 matching lines @@
       this.hierarchy,
       this.coreTypes,
       this.classBuilder,
       this.isInstanceMember,
       this.uri,
       this._typeInferrer,
       this.astFactory,
       {this.fieldDependencies})
       : enclosingScope = scope,
         library = library,
-        isDartLibrary = library.uri.scheme == "dart",
+        enableNative = (library.uri.scheme == "dart" || library.isPatch),
         needsImplicitSuperInitializer =
             coreTypes.objectClass != classBuilder?.cls,
         typePromoter = _typeInferrer.typePromoter,
         super(scope);
 
   bool get hasParserError => recoverableErrors.isNotEmpty;
 
   bool get inConstructor {
     return functionNestingLevel == 0 && member is KernelConstructorBuilder;
   }
@@ skipping 703 matching lines @@
           builder == null &&
           "loadLibrary" == name) {
         return buildCompileTimeError(
             "Deferred loading isn't implemented yet.", offsetForToken(token));
       } else if (!isQualified && isInstanceContext) {
         assert(builder == null);
         if (constantExpressionRequired) {
           return new UnresolvedAccessor(this, n, token);
         }
         return new ThisPropertyAccessor(this, token, n, null, null);
-      } else if (isDartLibrary &&
-          name == "main" &&
-          library.uri.path == "_builtin" &&
-          member?.name == "_getMainClosure") {
+      } else if (
+          // Optimization, if [enableNative] is false, this can't be
+          // dart:_builtin.
+          enableNative &&
+              name == "main" &&
+              library.uri.scheme == "dart" &&
+              library.uri.path == "_builtin" &&
+              member?.name == "_getMainClosure") {
         // TODO(ahe): https://github.com/dart-lang/sdk/issues/28989
         return astFactory.nullLiteral(token);
       } else {
         return new UnresolvedAccessor(this, n, token);
       }
     } else if (builder.isTypeDeclaration) {
       if (constantExpressionRequired &&
           builder.isTypeVariable &&
           !member.isConstructor) {
         addCompileTimeError(
@@ skipping 1645 matching lines @@
   }
 
   @override
   void handleRecoverableError(Token token, FastaMessage message) {
     bool silent = hasParserError;
     addCompileTimeError(message.charOffset, message.message, silent: silent);
   }
 
   @override
   Token handleUnrecoverableError(Token token, FastaMessage message) {
-    if (isDartLibrary && message.code == codeExpectedFunctionBody) {
+    if (enableNative && message.code == codeExpectedFunctionBody) {
       Token recover = library.loader.target.skipNativeClause(token);
       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);
       }
     }
@@ skipping 617 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return internalError("Unknown async modifier: $asyncToken");
   }
 }